I was messing around with min relay policies and found that under certain circumstances the mempool will accept things, then not relay to any peers.

Example made using wallet:
Transaction of size 6195, fee of 619 satoshis, minrelay of 100 satoshis per kvB. Mempool logic allows it:

```
        // No transactions are allowed below minRelayTxFee except from disconnected blocks
        if (!bypass_limits && nModifiedFees < ::minRelayTxFee.GetFee(nSize)) {
            return state.DoS(0, false, REJECT_INSUFFICIENTFEE, "min relay fee not met", false, strprintf("%d < %d", nModifiedFees, ::minRelayTxFee.GetFee(nSize)));
        }
```
and lets it into mempool

but in net_processing.cpp:

```
                    if (filterrate && txinfo.feeRate.GetFeePerK() < filterrate) {
                        continue;
                    }
```
this gets hit because the computed feerate is insufficient(printing I added):
```
0.00000099 BTC/kB
```

I'm not super at arithmetic so I'm opening this up in case someone has an easy fix. 

let me also get a reproducible test failure with this...
*/
    std::unique_ptr<CRollingBloomFilter> recentRejects GUARDED_BY(cs_main);
    uint256 hashRecentRejectsChainTip GUARDED_BY(cs_main);
    
    struct QueuedBlock {
        uint256 hash;
        const CBlockIndex* pindex;                               
        bool fValidatedHeaders;                                  
        std::unique_ptr<PartiallyDownloadedBlock> partialBlock;  
    };
    std::map<uint256, std::pair<NodeId, std::list<QueuedBlock>::iterator> > mapBlocksInFlight GUARDED_BY(cs_main);
    
    std::list<NodeId> lNodesAnnouncingHeaderAndIDs GUARDED_BY(cs_main);
    
    int nPreferredDownload GUARDED_BY(cs_main) = 0;
    
    int nPeersWithValidatedDownloads GUARDED_BY(cs_main) = 0;
    
    int g_outbound_peers_with_protect_from_disconnect GUARDED_BY(cs_main) = 0;
    
    std::atomic<int64_t> g_last_tip_update(0);
    
    typedef std::map<uint256, CTransactionRef> MapRelay;
    MapRelay mapRelay GUARDED_BY(cs_main);
    
    std::deque<std::pair<int64_t, MapRelay::iterator>> vRelayExpiration GUARDED_BY(cs_main);
    struct IteratorComparator
    {
        template<typename I>
        bool operator()(const I& a, const I& b) const