diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -611,6 +611,7 @@
 	torcontrol.cpp
 	txdb.cpp
 	txmempool.cpp
+	txorphanage.cpp
 	validation.cpp
 	validationinterface.cpp
 	versionbits.cpp
diff --git a/src/init.cpp b/src/init.cpp
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -58,6 +58,7 @@
 #include <torcontrol.h>
 #include <txdb.h>
 #include <txmempool.h>
+#include <txorphanage.h>
 #include <util/asmap.h>
 #include <util/check.h>
 #include <util/moneystr.h>
diff --git a/src/net_processing.h b/src/net_processing.h
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -11,7 +11,6 @@
 #include <validationinterface.h>
 
 extern RecursiveMutex cs_main;
-extern RecursiveMutex g_cs_orphans;
 
 namespace avalanche {
 struct ProofId;
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -37,6 +37,7 @@
 #include <streams.h>
 #include <tinyformat.h>
 #include <txmempool.h>
+#include <txorphanage.h>
 #include <util/check.h> // For NDEBUG compile time check
 #include <util/strencodings.h>
 #include <util/system.h>
@@ -47,10 +48,6 @@
 #include <memory>
 #include <typeinfo>
 
-/** Expiration time for orphan transactions in seconds */
-static constexpr int64_t ORPHAN_TX_EXPIRE_TIME = 20 * 60;
-/** Minimum time between orphan transactions expire time checks in seconds */
-static constexpr int64_t ORPHAN_TX_EXPIRE_INTERVAL = 5 * 60;
 /** How long to cache transactions in mapRelay for normal relay */
 static constexpr auto RELAY_TX_CACHE_TIME = 15min;
 /**
@@ -301,24 +298,6 @@
     return gArgs.GetArg("-maxaddrtosend", MAX_ADDR_TO_SEND);
 }
 
-struct COrphanTx {
-    // When modifying, adapt the copy of this definition in tests/DoS_tests.
-    CTransactionRef tx;
-    NodeId fromPeer;
-    int64_t nTimeExpire;
-    size_t list_pos;
-};
-
-/** Guards orphan transactions and extra txs for compact blocks */
-RecursiveMutex g_cs_orphans;
-/**
- * Map from txid to orphan transaction record. Limited by
- * -maxorphantx/DEFAULT_MAX_ORPHAN_TRANSACTIONS
- */
-std::map<TxId, COrphanTx> mapOrphanTransactions GUARDED_BY(g_cs_orphans);
-
-void EraseOrphansFor(NodeId peer);
-
 // Internal stuff
 namespace {
 /**
@@ -858,24 +837,6 @@
 /** Number of preferable block download peers. */
 int nPreferredDownload GUARDED_BY(cs_main) = 0;
 
-struct IteratorComparator {
-    template <typename I> bool operator()(const I &a, const I &b) const {
-        return &(*a) < &(*b);
-    }
-};
-
-/**
- * Index from the parents' COutPoint into the mapOrphanTransactions. Used
- * to remove orphan transactions from the mapOrphanTransactions
- */
-std::map<COutPoint,
-         std::set<std::map<TxId, COrphanTx>::iterator, IteratorComparator>>
-    mapOrphanTransactionsByPrev GUARDED_BY(g_cs_orphans);
-
-/** Orphan transactions in vector for quick random eviction */
-std::vector<std::map<TxId, COrphanTx>::iterator>
-    g_orphan_list GUARDED_BY(g_cs_orphans);
-
 /**
  * Orphan/conflicted/etc transactions that are kept for compact block
  * reconstruction.
@@ -1830,93 +1791,6 @@
     return true;
 }
 
-static int EraseOrphanTx(const TxId id) EXCLUSIVE_LOCKS_REQUIRED(g_cs_orphans) {
-    const auto it = mapOrphanTransactions.find(id);
-    if (it == mapOrphanTransactions.end()) {
-        return 0;
-    }
-    for (const CTxIn &txin : it->second.tx->vin) {
-        const auto itPrev = mapOrphanTransactionsByPrev.find(txin.prevout);
-        if (itPrev == mapOrphanTransactionsByPrev.end()) {
-            continue;
-        }
-        itPrev->second.erase(it);
-        if (itPrev->second.empty()) {
-            mapOrphanTransactionsByPrev.erase(itPrev);
-        }
-    }
-
-    size_t old_pos = it->second.list_pos;
-    assert(g_orphan_list[old_pos] == it);
-    if (old_pos + 1 != g_orphan_list.size()) {
-        // Unless we're deleting the last entry in g_orphan_list, move the last
-        // entry to the position we're deleting.
-        auto it_last = g_orphan_list.back();
-        g_orphan_list[old_pos] = it_last;
-        it_last->second.list_pos = old_pos;
-    }
-    g_orphan_list.pop_back();
-
-    mapOrphanTransactions.erase(it);
-    return 1;
-}
-
-void EraseOrphansFor(NodeId peer) {
-    LOCK(g_cs_orphans);
-    int nErased = 0;
-    auto iter = mapOrphanTransactions.begin();
-    while (iter != mapOrphanTransactions.end()) {
-        // Increment to avoid iterator becoming invalid.
-        const auto maybeErase = iter++;
-        if (maybeErase->second.fromPeer == peer) {
-            nErased += EraseOrphanTx(maybeErase->second.tx->GetId());
-        }
-    }
-    if (nErased > 0) {
-        LogPrint(BCLog::MEMPOOL, "Erased %d orphan tx from peer=%d\n", nErased,
-                 peer);
-    }
-}
-
-unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans) {
-    LOCK(g_cs_orphans);
-
-    unsigned int nEvicted = 0;
-    static int64_t nNextSweep;
-    int64_t nNow = GetTime();
-    if (nNextSweep <= nNow) {
-        // Sweep out expired orphan pool entries:
-        int nErased = 0;
-        int64_t nMinExpTime =
-            nNow + ORPHAN_TX_EXPIRE_TIME - ORPHAN_TX_EXPIRE_INTERVAL;
-        auto iter = mapOrphanTransactions.begin();
-        while (iter != mapOrphanTransactions.end()) {
-            const auto maybeErase = iter++;
-            if (maybeErase->second.nTimeExpire <= nNow) {
-                nErased += EraseOrphanTx(maybeErase->second.tx->GetId());
-            } else {
-                nMinExpTime =
-                    std::min(maybeErase->second.nTimeExpire, nMinExpTime);
-            }
-        }
-        // Sweep again 5 minutes after the next entry that expires in order to
-        // batch the linear scan.
-        nNextSweep = nMinExpTime + ORPHAN_TX_EXPIRE_INTERVAL;
-        if (nErased > 0) {
-            LogPrint(BCLog::MEMPOOL, "Erased %d orphan tx due to expiration\n",
-                     nErased);
-        }
-    }
-    FastRandomContext rng;
-    while (mapOrphanTransactions.size() > nMaxOrphans) {
-        // Evict a random orphan:
-        size_t randompos = rng.randrange(g_orphan_list.size());
-        EraseOrphanTx(g_orphan_list[randompos]->first);
-        ++nEvicted;
-    }
-    return nEvicted;
-}
-
 void PeerManagerImpl::Misbehaving(const NodeId pnode, const int howmuch,
                                   const std::string &message) {
     assert(howmuch > 0);
diff --git a/src/test/denialofservice_tests.cpp b/src/test/denialofservice_tests.cpp
--- a/src/test/denialofservice_tests.cpp
+++ b/src/test/denialofservice_tests.cpp
@@ -14,6 +14,7 @@
 #include <script/signingprovider.h>
 #include <script/standard.h>
 #include <serialize.h>
+#include <txorphanage.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <validation.h>
@@ -44,16 +45,6 @@
 
 // Tests these internal-to-net_processing.cpp methods:
 extern bool AddOrphanTx(const CTransactionRef &tx, NodeId peer);
-extern void EraseOrphansFor(NodeId peer);
-extern unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans);
-
-struct COrphanTx {
-    CTransactionRef tx;
-    NodeId fromPeer;
-    int64_t nTimeExpire;
-};
-extern std::map<uint256, COrphanTx>
-    mapOrphanTransactions GUARDED_BY(g_cs_orphans);
 
 static CService ip(uint32_t i) {
     struct in_addr s;
@@ -347,9 +338,9 @@
 }
 
 static CTransactionRef RandomOrphan() {
-    std::map<uint256, COrphanTx>::iterator it;
+    std::map<TxId, COrphanTx>::iterator it;
     LOCK2(cs_main, g_cs_orphans);
-    it = mapOrphanTransactions.lower_bound(InsecureRand256());
+    it = mapOrphanTransactions.lower_bound(TxId{InsecureRand256()});
     if (it == mapOrphanTransactions.end()) {
         it = mapOrphanTransactions.begin();
     }
diff --git a/src/test/fuzz/process_message.cpp b/src/test/fuzz/process_message.cpp
--- a/src/test/fuzz/process_message.cpp
+++ b/src/test/fuzz/process_message.cpp
@@ -12,6 +12,7 @@
 #include <scheduler.h>
 #include <script/script.h>
 #include <streams.h>
+#include <txorphanage.h>
 #include <validationinterface.h>
 #include <version.h>
 
diff --git a/src/test/fuzz/process_messages.cpp b/src/test/fuzz/process_messages.cpp
--- a/src/test/fuzz/process_messages.cpp
+++ b/src/test/fuzz/process_messages.cpp
@@ -7,6 +7,7 @@
 #include <net.h>
 #include <net_processing.h>
 #include <protocol.h>
+#include <txorphanage.h>
 #include <validation.h>
 #include <validationinterface.h>
 
diff --git a/src/txorphanage.h b/src/txorphanage.h
new file mode 100644
--- /dev/null
+++ b/src/txorphanage.h
@@ -0,0 +1,54 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_TXORPHANAGE_H
+#define BITCOIN_TXORPHANAGE_H
+
+#include <net.h>
+#include <primitives/transaction.h>
+#include <sync.h>
+
+/** Expiration time for orphan transactions in seconds */
+static constexpr int64_t ORPHAN_TX_EXPIRE_TIME = 20 * 60;
+
+/** Guards orphan transactions and extra txs for compact blocks */
+extern RecursiveMutex g_cs_orphans;
+
+struct COrphanTx {
+    // When modifying, adapt the copy of this definition in tests/DoS_tests.
+    CTransactionRef tx;
+    NodeId fromPeer;
+    int64_t nTimeExpire;
+    size_t list_pos;
+};
+
+int EraseOrphanTx(TxId id) EXCLUSIVE_LOCKS_REQUIRED(g_cs_orphans);
+void EraseOrphansFor(NodeId peer);
+unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans);
+
+/**
+ * Map from txid to orphan transaction record. Limited by
+ *  -maxorphantx/DEFAULT_MAX_ORPHAN_TRANSACTIONS
+ */
+extern std::map<TxId, COrphanTx> mapOrphanTransactions GUARDED_BY(g_cs_orphans);
+
+struct IteratorComparator {
+    template <typename I> bool operator()(const I &a, const I &b) const {
+        return &(*a) < &(*b);
+    }
+};
+
+/**
+ * Index from the parents' COutPoint into the mapOrphanTransactions. Used
+ *  to remove orphan transactions from the mapOrphanTransactions
+ */
+extern std::map<COutPoint, std::set<std::map<TxId, COrphanTx>::iterator,
+                                    IteratorComparator>>
+    mapOrphanTransactionsByPrev GUARDED_BY(g_cs_orphans);
+
+/** Orphan transactions in vector for quick random eviction */
+extern std::vector<std::map<TxId, COrphanTx>::iterator>
+    g_orphan_list GUARDED_BY(g_cs_orphans);
+
+#endif // BITCOIN_TXORPHANAGE_H
diff --git a/src/txorphanage.cpp b/src/txorphanage.cpp
new file mode 100644
--- /dev/null
+++ b/src/txorphanage.cpp
@@ -0,0 +1,113 @@
+// Copyright (c) 2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <txorphanage.h>
+
+#include <consensus/validation.h>
+#include <logging.h>
+#include <policy/policy.h>
+
+#include <cassert>
+
+/** Minimum time between orphan transactions expire time checks in seconds */
+static constexpr int64_t ORPHAN_TX_EXPIRE_INTERVAL = 5 * 60;
+
+RecursiveMutex g_cs_orphans;
+
+std::map<TxId, COrphanTx> mapOrphanTransactions GUARDED_BY(g_cs_orphans);
+
+std::map<COutPoint,
+         std::set<std::map<TxId, COrphanTx>::iterator, IteratorComparator>>
+    mapOrphanTransactionsByPrev GUARDED_BY(g_cs_orphans);
+
+std::vector<std::map<TxId, COrphanTx>::iterator>
+    g_orphan_list GUARDED_BY(g_cs_orphans);
+
+int EraseOrphanTx(TxId id) {
+    std::map<TxId, COrphanTx>::iterator it = mapOrphanTransactions.find(id);
+    if (it == mapOrphanTransactions.end()) {
+        return 0;
+    }
+    for (const CTxIn &txin : it->second.tx->vin) {
+        auto itPrev = mapOrphanTransactionsByPrev.find(txin.prevout);
+        if (itPrev == mapOrphanTransactionsByPrev.end()) {
+            continue;
+        }
+        itPrev->second.erase(it);
+        if (itPrev->second.empty()) {
+            mapOrphanTransactionsByPrev.erase(itPrev);
+        }
+    }
+
+    size_t old_pos = it->second.list_pos;
+    assert(g_orphan_list[old_pos] == it);
+    if (old_pos + 1 != g_orphan_list.size()) {
+        // Unless we're deleting the last entry in g_orphan_list, move the last
+        // entry to the position we're deleting.
+        auto it_last = g_orphan_list.back();
+        g_orphan_list[old_pos] = it_last;
+        it_last->second.list_pos = old_pos;
+    }
+    g_orphan_list.pop_back();
+
+    mapOrphanTransactions.erase(it);
+    return 1;
+}
+
+void EraseOrphansFor(NodeId peer) {
+    LOCK(g_cs_orphans);
+    int nErased = 0;
+    std::map<TxId, COrphanTx>::iterator iter = mapOrphanTransactions.begin();
+    while (iter != mapOrphanTransactions.end()) {
+        std::map<TxId, COrphanTx>::iterator maybeErase =
+            iter++; // increment to avoid iterator becoming invalid
+        if (maybeErase->second.fromPeer == peer) {
+            nErased += EraseOrphanTx(maybeErase->second.tx->GetId());
+        }
+    }
+    if (nErased > 0) {
+        LogPrint(BCLog::MEMPOOL, "Erased %d orphan tx from peer=%d\n", nErased,
+                 peer);
+    }
+}
+
+unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans) {
+    LOCK(g_cs_orphans);
+
+    unsigned int nEvicted = 0;
+    static int64_t nNextSweep;
+    int64_t nNow = GetTime();
+    if (nNextSweep <= nNow) {
+        // Sweep out expired orphan pool entries:
+        int nErased = 0;
+        int64_t nMinExpTime =
+            nNow + ORPHAN_TX_EXPIRE_TIME - ORPHAN_TX_EXPIRE_INTERVAL;
+        std::map<TxId, COrphanTx>::iterator iter =
+            mapOrphanTransactions.begin();
+        while (iter != mapOrphanTransactions.end()) {
+            std::map<TxId, COrphanTx>::iterator maybeErase = iter++;
+            if (maybeErase->second.nTimeExpire <= nNow) {
+                nErased += EraseOrphanTx(maybeErase->second.tx->GetId());
+            } else {
+                nMinExpTime =
+                    std::min(maybeErase->second.nTimeExpire, nMinExpTime);
+            }
+        }
+        // Sweep again 5 minutes after the next entry that expires in order to
+        // batch the linear scan.
+        nNextSweep = nMinExpTime + ORPHAN_TX_EXPIRE_INTERVAL;
+        if (nErased > 0) {
+            LogPrint(BCLog::MEMPOOL, "Erased %d orphan tx due to expiration\n",
+                     nErased);
+        }
+    }
+    FastRandomContext rng;
+    while (mapOrphanTransactions.size() > nMaxOrphans) {
+        // Evict a random orphan:
+        size_t randompos = rng.randrange(g_orphan_list.size());
+        EraseOrphanTx(g_orphan_list[randompos]->first);
+        ++nEvicted;
+    }
+    return nEvicted;
+}