@@ -3,6 +3,7 @@
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or https://opensource.org/license/mit/.
 
+import ipaddress
 from pathlib import Path
 import os
 import shlex
@@ -32,9 +33,22 @@ def main():
     # they will not be passed on.
     settings.update([
         "BASE_BUILD_DIR",
+        "BIND_TEST_ROUTABLE_IPV4",
+        "BIND_TEST_ROUTABLE_IPV6",
         "CI_FAILFAST_TEST_LEAVE_DANGLING",
     ])
 
+    ci_idx = sorted(path.name for path in Path(__file__).parent.glob("00_setup_env_*.sh")).index(Path(os.environ["FILE_ENV"]).name)
+    subnet_id = ci_idx % 256
+    ip4_subnet = ipaddress.IPv4Network(f"11.11.{subnet_id}.0/24")
+    ip4_addr = ip4_subnet[5]
+    ip6_subnet = ipaddress.IPv6Network(f"1111:1111:{subnet_id:x}::/112")
+    ip6_addr = ip6_subnet[5]
+
+    if not os.getenv("DANGER_RUN_CI_ON_HOST"):
+        os.environ["BIND_TEST_ROUTABLE_IPV4"] = str(ip4_addr)
+        os.environ["BIND_TEST_ROUTABLE_IPV6"] = str(ip6_addr)
+
     # Append $USER to /tmp/env to support multi-user systems and $CONTAINER_NAME
     # to allow support starting multiple runs simultaneously by the same user.
     env_file = "/tmp/env-{u}-{c}".format(
@@ -114,8 +128,8 @@ def main():
                 sys.exit(1)
             CI_CCACHE_MOUNT = f"type=bind,src={os.environ['CCACHE_DIR']},dst={os.environ['CCACHE_DIR']}"
 
-        run(["docker", "network", "create", "--ipv6", "--subnet", "1111:1111::/112", "ci-ip6net"], check=False)
-        run(["docker", "network", "create", "--subnet", "1.1.1.0/24", "ci-ip4net"], check=False)
+        network_name = f"{os.environ['CONTAINER_NAME']}-net"
+        run(["docker", "network", "create", "--ipv6", f"--subnet={ip6_subnet}", f"--subnet={ip4_subnet}", network_name])
 
         if os.getenv("RESTART_CI_DOCKER_BEFORE_RUN"):
             print("Restart docker before run to stop and clear all containers started with --rm")
@@ -144,8 +158,9 @@ def main():
             *CI_BUILD_MOUNT,
             f"--env-file={env_file}",
             f"--name={os.environ['CONTAINER_NAME']}",
-            "--network=ci-ip6net",
-            "--ip6=1111:1111::5", # Used by some of the tests, don't change it just here (keep them in sync).
+            f"--network={network_name}",
+            f"--ip={ip4_addr}",
+            f"--ip6={ip6_addr}",
             f"--platform={os.environ['CI_IMAGE_PLATFORM']}",
             os.environ["CONTAINER_NAME"],
         ]
@@ -156,8 +171,6 @@ def main():
             text=True,
         ).stdout.strip()
 
-        run(["docker", "network", "connect", "--ip=1.1.1.5", "ci-ip4net", container_id]) # The IP address is used by some of the tests, don't change it just here (keep them in sync).
-
     def ci_exec(cmd_inner, **kwargs):
         if os.getenv("DANGER_RUN_CI_ON_HOST"):
             prefix = []
@@ -199,6 +212,7 @@ def ci_exec(cmd_inner, **kwargs):
     if not os.getenv("DANGER_RUN_CI_ON_HOST"):
         print("Stop and remove CI container by ID")
         run(["docker", "container", "kill", container_id])
+        run(["docker", "network", "rm", network_name])
 
 
 if __name__ == "__main__":
 
@@ -166,7 +166,7 @@ static int GetChainParams(const std::vector<std::string>& args, std::string& str
     UniValue result{UniValue::VOBJ};
     result.pushKV("chain", params.GetChainTypeString());
     result.pushKV("test_chain", params.IsTestChain());
-    result.pushKV("genesis", HexStr(consensus.hashGenesisBlock));
+    result.pushKV("genesis", consensus.hashGenesisBlock.GetHex());
     result.pushKV("subsidy_halving_interval", consensus.nSubsidyHalvingInterval);
 
     if (consensus.signet_blocks) {
 
@@ -966,6 +966,16 @@ void HTTPRemoteClient::Receive()
             m_recv_buffer.end(),
             buf,
             buf + nrecv);
+
+        m_total_bytes_received += static_cast<uint64_t>(nrecv);
+        LogDebug(
+            BCLog::HTTP,
+            "Received %d bytes from %s (id=%llu): total=%llu buffered=%zu",
+            nrecv,
+            m_origin,
+            m_id,
+            m_total_bytes_received,
+            m_recv_buffer.size());
     }
 }
 
 
@@ -563,6 +563,9 @@ class HTTPRemoteClient
      */
     std::string m_recv_buffer{};
 
+    //! Running total of bytes read from this client's socket.
+    uint64_t m_total_bytes_received{0};
+
     //! Requests from a client must be processed in the order in which
     //! they were received, blocking on a per-client basis. We read
     //! one request at a time from the socket buffer then pass it to a worker.
 
@@ -199,8 +199,6 @@ static constexpr double MAX_ADDR_RATE_PER_SECOND{0.1};
  *  based increments won't go above this, but the MAX_ADDR_TO_SEND increment following GETADDR
  *  is exempt from this limit). */
 static constexpr size_t MAX_ADDR_PROCESSING_TOKEN_BUCKET{MAX_ADDR_TO_SEND};
-/** For private broadcast, send a transaction to this many peers. */
-static constexpr size_t NUM_PRIVATE_BROADCAST_PER_TX{3};
 /** Private broadcast connections must complete within this time. Disconnect the peer if it takes longer. */
 static constexpr auto PRIVATE_BROADCAST_MAX_CONNECTION_LIFETIME{3min};
 
@@ -1745,7 +1743,7 @@ void PeerManagerImpl::ReattemptInitialBroadcast(CScheduler& scheduler)
 
 void PeerManagerImpl::ReattemptPrivateBroadcast(CScheduler& scheduler)
 {
-    // Remove stale transactions that are no longer relevant (e.g. already in
+    // Resolve stale transactions that are no longer relevant (e.g. already in
     // the mempool or mined) and count the remaining ones.
     size_t num_for_rebroadcast{0};
     const auto stale_txs = m_tx_for_private_broadcast.GetStale();
@@ -1755,6 +1753,7 @@ void PeerManagerImpl::ReattemptPrivateBroadcast(CScheduler& scheduler)
             LOCK(cs_main);
             auto mempool_acceptable = m_chainman.ProcessTransaction(stale_tx, /*test_accept=*/true);
             if (mempool_acceptable.m_result_type == MempoolAcceptResult::ResultType::VALID) {
+                if (!m_tx_for_private_broadcast.TryGrantRetry(stale_tx)) continue;
                 LogDebug(BCLog::PRIVBROADCAST,
                          "Reattempting broadcast of stale txid=%s wtxid=%s",
                          stale_tx->GetHash().ToString(), stale_tx->GetWitnessHash().ToString());
@@ -1763,7 +1762,7 @@ void PeerManagerImpl::ReattemptPrivateBroadcast(CScheduler& scheduler)
                 LogDebug(BCLog::PRIVBROADCAST, "Giving up broadcast attempts for txid=%s wtxid=%s: %s",
                          stale_tx->GetHash().ToString(), stale_tx->GetWitnessHash().ToString(),
                          mempool_acceptable.m_state.ToString());
-                m_tx_for_private_broadcast.Remove(stale_tx);
+                m_tx_for_private_broadcast.MarkResolved(stale_tx);
             }
         }
 
@@ -1843,11 +1842,18 @@ void PeerManagerImpl::FinalizeNode(const CNode& node)
         LOCK(m_headers_presync_mutex);
         m_headers_presync_stats.erase(nodeid);
     }
-    if (node.IsPrivateBroadcastConn() &&
-        !m_tx_for_private_broadcast.DidNodeConfirmReception(nodeid) &&
-        m_tx_for_private_broadcast.HavePendingTransactions()) {
-
-        m_connman.m_private_broadcast.NumToOpenAdd(1);
+    if (node.IsPrivateBroadcastConn()) {
+        m_tx_for_private_broadcast.NodeDisconnected(nodeid);
+        // We consider a transaction sent to a peer if we sent them an INV.
+        // Normally they should request the transaction with GETDATA, but this may
+        // not happen if they are already aware of the transaction.
+        // If we didn't send them an INV, schedule a new connection to compensate
+        // for this send failure. Whether we sent them an INV is not readily
+        // available here, so use fSuccessfullyConnected because INV is sent right
+        // after a successful handshake when there is a pending transaction.
+        if (!node.fSuccessfullyConnected && m_tx_for_private_broadcast.HavePendingTransactions()) {
+            m_connman.m_private_broadcast.NumToOpenAdd(1);
+        }
     }
     LogDebug(BCLog::NET, "Cleared nodestate for peer=%d\n", nodeid);
 }
@@ -1988,11 +1994,9 @@ std::vector<CTransactionRef> PeerManagerImpl::AbortPrivateBroadcast(const uint25
     for (const auto& tx_info : snapshot) {
         const CTransactionRef& tx{tx_info.tx};
         if (tx->GetHash().ToUint256() != id && tx->GetWitnessHash().ToUint256() != id) continue;
-        if (const auto peer_acks{m_tx_for_private_broadcast.Remove(tx)}) {
+        if (const auto remaining_sends{m_tx_for_private_broadcast.Remove(tx)}) {
             removed_txs.push_back(tx);
-            if (NUM_PRIVATE_BROADCAST_PER_TX > *peer_acks) {
-                connections_cancelled += (NUM_PRIVATE_BROADCAST_PER_TX - *peer_acks);
-            }
+            connections_cancelled += *remaining_sends;
         }
     }
     m_connman.m_private_broadcast.NumToOpenSub(connections_cancelled);
@@ -2495,8 +2499,8 @@ node::TransactionError PeerManagerImpl::InitiateTxBroadcastPrivate(const CTransa
     const auto txstr{strprintf("txid=%s, wtxid=%s", tx->GetHash().ToString(), tx->GetWitnessHash().ToString())};
     switch (m_tx_for_private_broadcast.Add(tx)) {
     case PrivateBroadcast::AddResult::Added:
-        LogDebug(BCLog::PRIVBROADCAST, "Requesting %d new connections due to %s", NUM_PRIVATE_BROADCAST_PER_TX, txstr);
-        m_connman.m_private_broadcast.NumToOpenAdd(NUM_PRIVATE_BROADCAST_PER_TX);
+        LogDebug(BCLog::PRIVBROADCAST, "Requesting %d new connections due to %s", PrivateBroadcast::INITIAL_CONNECTION_COUNT, txstr);
+        m_connman.m_private_broadcast.NumToOpenAdd(PrivateBroadcast::INITIAL_CONNECTION_COUNT);
         return node::TransactionError::OK;
     case PrivateBroadcast::AddResult::AlreadyPresent:
         LogDebug(BCLog::PRIVBROADCAST, "Ignoring unnecessary request to schedule an already scheduled transaction: %s", txstr);
@@ -4722,15 +4726,10 @@ void PeerManagerImpl::ProcessMessage(Peer& peer, CNode& pfrom, const std::string
         const uint256& hash = peer.m_wtxid_relay ? wtxid.ToUint256() : txid.ToUint256();
         AddKnownTx(peer, hash);
 
-        if (const auto num_broadcasted{m_tx_for_private_broadcast.Remove(ptx)}) {
+        if (m_tx_for_private_broadcast.MarkResolved(ptx)) {
             LogDebug(BCLog::PRIVBROADCAST, "Received our privately broadcast transaction (txid=%s) from the "
-                                           "network from %s; stopping private broadcast attempts",
+                                           "network from %s",
                      txid.ToString(), pfrom.LogPeer());
-            if (NUM_PRIVATE_BROADCAST_PER_TX > num_broadcasted.value()) {
-                // Not all of the initial NUM_PRIVATE_BROADCAST_PER_TX connections were needed.
-                // Tell CConnman it does not need to start the remaining ones.
-                m_connman.m_private_broadcast.NumToOpenSub(NUM_PRIVATE_BROADCAST_PER_TX - num_broadcasted.value());
-            }
         }
 
         LOCK2(cs_main, m_tx_download_mutex);
 
@@ -14,12 +14,21 @@ PrivateBroadcast::AddResult PrivateBroadcast::Add(const CTransactionRef& tx)
     EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
 {
     LOCK(m_mutex);
+    // Cleanup finished transactions
+    std::erase_if(m_transactions, [this](const auto& entry) {
+        const auto& state{entry.second};
+        return state.resolved && !IsPending(state) &&
+               std::ranges::all_of(state.send_statuses, [](const auto& status) { return status.disconnected; });
+    });
+
     if (const auto it{m_transactions.find(tx)}; it != m_transactions.end()) {
-        if (IsPending(it->second)) return AddResult::AlreadyPresent;
+        if (it->second.send_statuses.size() < m_max_send_attempts) return AddResult::AlreadyPresent;
 
-        // An exhausted transaction can be explicitly retried by adding it again.
+        // A transaction that has reached m_max_send_attempts can be explicitly retried by adding it again.
         it->second.time_added = NodeClock::now();
         it->second.send_statuses.clear();
+        it->second.planned_sends = INITIAL_CONNECTION_COUNT;
+        it->second.resolved = false;
         return AddResult::Added;
     }
 
@@ -35,12 +44,43 @@ std::optional<size_t> PrivateBroadcast::Remove(const CTransactionRef& tx)
     LOCK(m_mutex);
     const auto handle{m_transactions.extract(tx)};
     if (handle) {
-        const auto p{DerivePriority(handle.mapped().send_statuses)};
-        return p.num_confirmed;
+        const auto& state{handle.mapped()};
+        const size_t planned{std::min(state.planned_sends, m_max_send_attempts)};
+        const size_t actual{state.send_statuses.size()};
+        return planned > actual ? planned - actual : 0;
     }
     return std::nullopt;
 }
 
+bool PrivateBroadcast::MarkResolved(const CTransactionRef& tx)
+{
+    LOCK(m_mutex);
+    const auto it{m_transactions.find(tx)};
+    if (it == m_transactions.end()) return false;
+    it->second.resolved = true;
+    return true;
+}
+
+void PrivateBroadcast::NodeDisconnected(NodeId nodeid)
+{
+    LOCK(m_mutex);
+    if (const auto entry{GetSendStatusByNode(nodeid)}) {
+        entry->send_status.disconnected = true;
+    }
+}
+
+bool PrivateBroadcast::TryGrantRetry(const CTransactionRef& tx)
+{
+    LOCK(m_mutex);
+    const auto it{m_transactions.find(tx)};
+    if (it == m_transactions.end() ||
+        it->second.resolved ||
+        IsPending(it->second) ||
+        it->second.planned_sends >= m_max_send_attempts) return false;
+    ++it->second.planned_sends;
+    return true;
+}
+
 std::optional<CTransactionRef> PrivateBroadcast::PickTxForSend(const NodeId& will_send_to_nodeid, const CService& will_send_to_address)
     EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
 {
@@ -87,17 +127,6 @@ void PrivateBroadcast::NodeConfirmedReception(const NodeId& nodeid)
     }
 }
 
-bool PrivateBroadcast::DidNodeConfirmReception(const NodeId& nodeid)
-    EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
-{
-    LOCK(m_mutex);
-    const auto tx_and_status{GetSendStatusByNode(nodeid)};
-    if (tx_and_status.has_value()) {
-        return tx_and_status.value().send_status.confirmed.has_value();
-    }
-    return false;
-}
-
 bool PrivateBroadcast::HavePendingTransactions()
     EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
 {
@@ -112,7 +141,7 @@ std::vector<CTransactionRef> PrivateBroadcast::GetStale() const
     const auto now{NodeClock::now()};
     std::vector<CTransactionRef> stale;
     for (const auto& [tx, state] : m_transactions) {
-        if (!IsPending(state)) continue;
+        if (state.resolved || state.planned_sends >= m_max_send_attempts) continue;
         const Priority p{DerivePriority(state.send_statuses)};
         if (p.num_confirmed == 0) {
             if (state.time_added < now - INITIAL_STALE_DURATION) stale.push_back(tx);
@@ -131,6 +160,7 @@ std::vector<PrivateBroadcast::TxBroadcastInfo> PrivateBroadcast::GetBroadcastInf
     entries.reserve(m_transactions.size());
 
     for (const auto& [tx, state] : m_transactions) {
+        if (state.resolved) continue;
         std::vector<PeerSendInfo> peers;
         peers.reserve(state.send_statuses.size());
         for (const auto& status : state.send_statuses) {
@@ -145,7 +175,9 @@ std::vector<PrivateBroadcast::TxBroadcastInfo> PrivateBroadcast::GetBroadcastInf
 
 bool PrivateBroadcast::IsPending(const TxSendStatus& status) const
 {
-    return status.send_statuses.size() < m_max_send_attempts;
+    // Deliberately ignore resolved so all initially scheduled connections can complete.
+    const size_t limit{std::min(status.planned_sends, m_max_send_attempts)};
+    return status.send_statuses.size() < limit;
 }
 
 PrivateBroadcast::Priority PrivateBroadcast::DerivePriority(const std::vector<SendStatus>& sent_to)