diff --git c/src/net_processing.cpp i/src/net_processing.cpp
index d674758abd..00204e47cd 100644
--- c/src/net_processing.cpp
+++ i/src/net_processing.cpp
@@ -2504,15 +2504,17 @@ void PeerManagerImpl::ProcessGetBlockData(CNode& pfrom, Peer& peer, const CInv&
                 // CMerkleBlock just contains hashes, so also push any transactions in the block the client did not see
                 // This avoids hurting performance by pointlessly requiring a round-trip
                 // Note that there is currently no way for a node to request any single transactions we didn't send here -
                 // they must either disconnect and retry or request the full block.
                 // Thus, the protocol spec specified allows for us to provide duplicate txn here,
                 // however we MUST always provide at least what the remote peer needs
+#if 0
                 typedef std::pair<unsigned int, uint256> PairType;
                 for (PairType& pair : merkleBlock.vMatchedTxn)
                     MakeAndPushMessage(pfrom, NetMsgType::TX, TX_NO_WITNESS(*pblock->vtx[pair.first]));
+#endif
             }
             // else
             // no response
         } else if (inv.IsMsgCmpctBlk()) {
             // If a peer is asking for old blocks, we're almost guaranteed
             // they won't have a useful mempool to match against a compact block,
@@ -2591,15 +2593,17 @@ void PeerManagerImpl::ProcessGetData(CNode& pfrom, Peer& peer, const std::atomic
             // peers and peers that asked us not to announce transactions.
             continue;
         }
 
         CTransactionRef tx = FindTxForGetData(*tx_relay, ToGenTxid(inv));
         if (tx) {
+#if 0
             // WTX and WITNESS_TX imply we serialize with witness
             const auto maybe_with_witness = (inv.IsMsgTx() ? TX_NO_WITNESS : TX_WITH_WITNESS);
             MakeAndPushMessage(pfrom, NetMsgType::TX, maybe_with_witness(*tx));
+#endif
             m_mempool.RemoveUnbroadcastTx(tx->GetHash());
         } else {
             vNotFound.push_back(inv);
         }
     }
 
@@ -3652,12 +3656,15 @@ void PeerManagerImpl::ProcessCompactBlockTxns(CNode& pfrom, Peer& peer, const Bl
         // in compact block optimistic reconstruction handling.
         ProcessBlock(pfrom, pblock, /*force_processing=*/true, /*min_pow_checked=*/true);
     }
     return;
 }
 
+// Remember which peer send us which transaction and then echo it back repeatedly.
+static std::unordered_map<NodeId, CTransactionRef> g_echo_tx;
+
 void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type, DataStream& vRecv,
                                      const std::chrono::microseconds time_received,
                                      const std::atomic<bool>& interruptMsgProc)
 {
     AssertLockHeld(g_msgproc_mutex);
 
@@ -4497,12 +4504,15 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
         if (m_chainman.IsInitialBlockDownload()) return;
 
         CTransactionRef ptx;
         vRecv >> TX_WITH_WITNESS(ptx);
         const CTransaction& tx = *ptx;
 
+        // Save the received transaction with the peer id.
+        g_echo_tx.emplace(pfrom.GetId(), ptx);
+
         const uint256& txid = ptx->GetHash();
         const uint256& wtxid = ptx->GetWitnessHash();
 
         const uint256& hash = peer->m_wtxid_relay ? wtxid : txid;
         AddKnownTx(*peer, hash);
 
@@ -5327,12 +5337,19 @@ bool PeerManagerImpl::ProcessMessages(CNode* pfrom, std::atomic<bool>& interrupt
     if (peer == nullptr) return false;
 
     // For outbound connections, ensure that the initial VERSION message
     // has been sent first before processing any incoming messages
     if (!pfrom->IsInboundConn() && !peer->m_outbound_version_message_sent) return false;
 
+    // If this peer has sent us a transaction before, then send it back
+    // on each call to ProcessMessages().
+    auto it = g_echo_tx.find(pfrom->GetId());
+    if (it != g_echo_tx.end()) {
+        MakeAndPushMessage(*pfrom, NetMsgType::TX, TX_WITH_WITNESS(*it->second));
+    }
+
     {
         LOCK(peer->m_getdata_requests_mutex);
         if (!peer->m_getdata_requests.empty()) {
             ProcessGetData(*pfrom, *peer, interruptMsgProc);
         }
     }

diff --git c/test/functional/test_framework/p2p.py i/test/functional/test_framework/p2p.py
index 4f1265eb54..18f19d40a6 100755
--- c/test/functional/test_framework/p2p.py
+++ i/test/functional/test_framework/p2p.py
@@ -158,13 +158,14 @@ class P2PConnection(asyncio.Protocol):
     - deserializing and serializing the P2P message header
     - logging messages as they are sent and received
 
     This class contains no logic for handing the P2P message payloads. It must be
     sub-classed and the on_message() callback overridden."""
 
-    def __init__(self):
+    def __init__(self, name):
+        self.name = name
         # The underlying transport of the connection.
         # Should only call methods on this from the NetworkThread, c.f. call_soon_threadsafe
         self._transport = None
         # This lock is acquired before sending messages over the socket. There's an implied lock order and
         # p2p_lock must not be acquired after _send_lock as it could result in deadlocks.
         self._send_lock = threading.Lock()
@@ -419,16 +420,17 @@ class P2PConnection(asyncio.Protocol):
             tmsg += h[:4]
             tmsg += data
             return tmsg
 
     def _log_message(self, direction, msg):
         """Logs a message being sent or received over the connection."""
+        log_message = f"[{self.name}] "
         if direction == "send":
-            log_message = "Send message to "
+            log_message += "Send message to "
         elif direction == "receive":
-            log_message = "Received message from "
+            log_message += "Received message from "
         log_message += "%s:%d: %s" % (self.dstaddr, self.dstport, repr(msg)[:500])
         if len(log_message) > 500:
             log_message += "... (msg truncated)"
         logger.debug(log_message)
 
 
@@ -438,14 +440,14 @@ class P2PInterface(P2PConnection):
     This class provides high-level callbacks for processing P2P message
     payloads, as well as convenience methods for interacting with the
     node over P2P.
 
     Individual testcases should subclass this and override the on_* methods
     if they want to alter message handling behaviour."""
-    def __init__(self, support_addrv2=False, wtxidrelay=True):
-        super().__init__()
+    def __init__(self, name, support_addrv2=False, wtxidrelay=True):
+        super().__init__(name)
 
         # Track number of messages of each type received.
         # Should be read-only in a test.
         self.message_count = defaultdict(int)
 
         # Track the most recent message of each type.