diff --git a/src/avalanche/peermanager.cpp b/src/avalanche/peermanager.cpp
--- a/src/avalanche/peermanager.cpp
+++ b/src/avalanche/peermanager.cpp
@@ -173,9 +173,7 @@
 }
 
 static bool isOrphanState(const ProofValidationState &state) {
-    return state.GetResult() == ProofValidationResult::MISSING_UTXO ||
-           state.GetResult() == ProofValidationResult::HEIGHT_MISMATCH ||
-           state.GetResult() == ProofValidationResult::IMMATURE_UTXO;
+    return state.GetResult() == ProofValidationResult::IMMATURE_UTXO;
 }
 
 bool PeerManager::updateNextPossibleConflictTime(
@@ -237,16 +235,12 @@
                    return proof->verify(validationState,
                                         ::ChainstateActive().CoinsTip()))) {
         if (isOrphanState(validationState)) {
-            // Only accept orphan proofs if there's room in the orphan pool.
-            auto status = orphanProofPool.addProofIfNoConflict(proof);
-            if (status != ProofPool::AddProofStatus::SUCCEED) {
-                // Attempt proof replacement
-                orphanProofPool.addProofIfPreferred(proof);
-            } else if (orphanProofPool.countProofs() >
-                       AVALANCHE_MAX_ORPHAN_PROOFS) {
-                // Adding this proof exceeds the orphan pool limit, so remove
-                // it.
-                orphanProofPool.removeProof(proof->getId());
+            orphanProofPool.addProofIfPreferred(proof);
+            if (orphanProofPool.countProofs() > AVALANCHE_MAX_ORPHAN_PROOFS) {
+                // Adding this proof exceeds the orphan pool limit, so evict
+                // the lowest scoring proof.
+                orphanProofPool.removeProof(
+                    orphanProofPool.getLowestScoreProof()->getId());
             }
 
             return invalidate(ProofRegistrationResult::ORPHAN, "orphan-proof");
diff --git a/src/avalanche/test/peermanager_tests.cpp b/src/avalanche/test/peermanager_tests.cpp
--- a/src/avalanche/test/peermanager_tests.cpp
+++ b/src/avalanche/test/peermanager_tests.cpp
@@ -7,6 +7,7 @@
 #include <avalanche/proofbuilder.h>
 #include <avalanche/proofcomparator.h>
 #include <avalanche/test/util.h>
+#include <config.h>
 #include <script/standard.h>
 #include <util/time.h>
 #include <util/translation.h>
@@ -589,13 +590,10 @@
 }
 
 BOOST_AUTO_TEST_CASE(node_binding_reorg) {
+    gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "2");
     avalanche::PeerManager pm(*m_node.scheduler);
 
-    auto key = CKey::MakeCompressedKey();
-
-    COutPoint utxo = createUtxo(key);
-
-    auto proof = buildProofWithOutpoints(key, {utxo}, 10 * COIN);
+    auto proof = buildRandomProof(MIN_VALID_PROOF_SCORE, 99);
     const ProofId &proofid = proof->getId();
 
     PeerId peerid = TestPeerManager::registerAndGetPeerId(pm, proof);
@@ -609,11 +607,13 @@
         BOOST_CHECK(TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
 
-    // Orphan the proof
+    // Orphan the proof by reorging to a shorter chain that makes the proof
+    // immature
     {
-        LOCK(cs_main);
-        CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
-        coins.SpendCoin(utxo);
+        BlockValidationState state;
+        ::ChainstateActive().InvalidateBlock(GetConfig(), state,
+                                             ::ChainActive().Tip());
+        BOOST_CHECK_EQUAL(::ChainActive().Height(), 99);
     }
 
     pm.updatedBlockTip();
@@ -626,7 +626,15 @@
     BOOST_CHECK(pm.verify());
 
     // Make the proof great again
-    addCoin(utxo, key);
+    {
+        // Advance the clock so the newly mined block won't collide with the
+        // other deterministically-generated blocks
+        SetMockTime(GetTime() + 20);
+        mineBlocks(1);
+        BlockValidationState state;
+        BOOST_CHECK(::ChainstateActive().ActivateBestChain(GetConfig(), state));
+        BOOST_CHECK_EQUAL(::ChainActive().Height(), 100);
+    }
 
     pm.updatedBlockTip();
     BOOST_CHECK(!pm.isOrphan(proofid));
@@ -713,33 +721,7 @@
     avalanche::PeerManager pm(*m_node.scheduler);
 
     auto key = CKey::MakeCompressedKey();
-
-    COutPoint outpoint1 = COutPoint(TxId(GetRandHash()), 0);
-    COutPoint outpoint2 = COutPoint(TxId(GetRandHash()), 0);
-    COutPoint outpoint3 = COutPoint(TxId(GetRandHash()), 0);
-    COutPoint outpoint4 = COutPoint(TxId(GetRandHash()), 0);
-
-    const Amount v = 5 * COIN;
-    const int height = 98;
-    const int wrongHeight = 99;
-    const int immatureHeight = 100;
-
-    const auto makeProof = [&](const COutPoint &outpoint, const int h) {
-        return buildProofWithOutpoints(key, {outpoint}, v, key, 0, h);
-    };
-
-    auto proof1 = makeProof(outpoint1, height);
-    auto proof2 = makeProof(outpoint2, height);
-    auto proof3 = makeProof(outpoint3, wrongHeight);
-    auto proof4 = makeProof(outpoint4, immatureHeight);
-
-    // Add outpoints, except for proof 2
-    addCoin(outpoint1, key, v, height);
-    addCoin(outpoint3, key, v, height);
-    addCoin(outpoint4, key, v, immatureHeight);
-
-    // Add the proofs
-    BOOST_CHECK(pm.registerProof(proof1));
+    int immatureHeight = 100;
 
     auto registerOrphan = [&](const ProofRef &proof) {
         ProofRegistrationState state;
@@ -747,10 +729,6 @@
         BOOST_CHECK(state.GetResult() == ProofRegistrationResult::ORPHAN);
     };
 
-    registerOrphan(proof2);
-    registerOrphan(proof3);
-    registerOrphan(proof4);
-
     auto checkOrphan = [&](const ProofRef &proof, bool expectedOrphan) {
         const ProofId &proofid = proof->getId();
         BOOST_CHECK(pm.exists(proofid));
@@ -767,135 +745,52 @@
         BOOST_CHECK_EQUAL(ret, !expectedOrphan);
     };
 
-    // Good
-    checkOrphan(proof1, false);
-    // MISSING_UTXO
-    checkOrphan(proof2, true);
-    // HEIGHT_MISMATCH
-    checkOrphan(proof3, true);
-    // IMMATURE_UTXO
-    checkOrphan(proof4, true);
-
-    // Add outpoint2, proof2 is no longer considered orphan
-    addCoin(outpoint2, key, v, height);
-
-    pm.updatedBlockTip();
-    checkOrphan(proof2, false);
-
-    // The status of proof1 and proof3 are unchanged
-    checkOrphan(proof1, false);
-    checkOrphan(proof3, true);
-
-    // Mine a block to increase the chain height for proof4 verification
-    mineBlocks(1);
-    pm.updatedBlockTip();
-    checkOrphan(proof4, false);
-
-    // Spend outpoint1, proof1 becomes orphan
-    {
-        LOCK(cs_main);
-        CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
-        coins.SpendCoin(outpoint1);
-    }
-
-    pm.updatedBlockTip();
-    checkOrphan(proof1, true);
-
-    // The status of proof2 and proof3 are unchanged
-    checkOrphan(proof2, false);
-    checkOrphan(proof3, true);
-
-    // A reorg could make a previous HEIGHT_MISMATCH become valid
-    {
-        LOCK(cs_main);
-        CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
-        coins.SpendCoin(outpoint3);
-    }
-    addCoin(outpoint3, key, v, wrongHeight);
-
-    pm.updatedBlockTip();
-    checkOrphan(proof3, false);
-
-    // The status of proof 1 and proof2 are unchanged
-    checkOrphan(proof1, true);
-    checkOrphan(proof2, false);
-
-    // Track expected orphans so we can test them later
+    // Track orphans so we can test them later
     std::vector<ProofRef> orphans;
-    orphans.push_back(proof1);
 
     // Fill up orphan pool to test the size limit
-    for (uint32_t i = 1; i < AVALANCHE_MAX_ORPHAN_PROOFS; i++) {
+    for (int64_t i = 1; i <= AVALANCHE_MAX_ORPHAN_PROOFS; i++) {
         COutPoint outpoint = COutPoint(TxId(GetRandHash()), 0);
-        auto proof =
-            buildProofWithOutpoints(key, {outpoint}, 10 * COIN, key, 0, height);
+        auto proof = buildProofWithOutpoints(key, {outpoint}, i * COIN, key, 0,
+                                             immatureHeight);
+        addCoin(outpoint, key, i * COIN, immatureHeight);
         registerOrphan(proof);
+        checkOrphan(proof, true);
         orphans.push_back(proof);
     }
 
-    // New orphans are rejected when the pool is full, even if they have higher
-    // proof scores.
-    {
+    // More orphans evict lower scoring proofs
+    for (auto i = 0; i < 100; i++) {
         COutPoint outpoint = COutPoint(TxId(GetRandHash()), 0);
-        auto proof =
-            buildProofWithOutpoints(key, {outpoint}, 20 * COIN, key, 0, height);
-        registerOrphan(proof);
-        BOOST_CHECK(!pm.exists(proof->getId()));
-    }
-
-    // Replacement when the pool is full still works
-    {
-        auto proof = buildProofWithOutpoints(key, {outpoint1}, 10 * COIN, key,
-                                             1, height);
+        auto proof = buildProofWithOutpoints(key, {outpoint}, 200 * COIN, key,
+                                             0, immatureHeight);
+        addCoin(outpoint, key, 200 * COIN, immatureHeight);
         registerOrphan(proof);
         checkOrphan(proof, true);
-        BOOST_CHECK(!pm.exists(proof1->getId()));
         orphans.push_back(proof);
+        BOOST_CHECK(!pm.exists(orphans.front()->getId()));
         orphans.erase(orphans.begin());
     }
 
-    // Reorg so that some more proofs become orphans
-    {
-        LOCK(cs_main);
-        CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
-        coins.SpendCoin(outpoint2);
-        coins.SpendCoin(outpoint3);
-        coins.SpendCoin(outpoint4);
-
-        orphans.push_back(proof2);
-        orphans.push_back(proof3);
-        orphans.push_back(proof4);
-    }
-
-    pm.updatedBlockTip();
-
-    // New orphans are rejected when the pool is full, even if they have higher
-    // proof scores.
+    // Replacement when the pool is full still works
     {
-        COutPoint outpoint = COutPoint(TxId(GetRandHash()), 0);
-        auto proof =
-            buildProofWithOutpoints(key, {outpoint}, 20 * COIN, key, 0, height);
+        const COutPoint &outpoint =
+            orphans.front()->getStakes()[0].getStake().getUTXO();
+        auto proof = buildProofWithOutpoints(key, {outpoint}, 101 * COIN, key,
+                                             1, immatureHeight);
         registerOrphan(proof);
-        BOOST_CHECK(!pm.exists(proof->getId()));
-    }
-
-    // Even though we've exceeded the orphan pool limit, the reorged proofs are
-    // still being tracked.
-    for (auto &proof : orphans) {
         checkOrphan(proof, true);
+        orphans.push_back(proof);
+        BOOST_CHECK(!pm.exists(orphans.front()->getId()));
+        orphans.erase(orphans.begin());
     }
 
-    // Another block causes orphans to be trimmed to the limit
+    // Mine a block to increase the chain height, making all orphans mature
+    mineBlocks(1);
     pm.updatedBlockTip();
-
-    int numOrphans = 0;
-    for (auto &proof : orphans) {
-        if (pm.exists(proof->getId())) {
-            checkOrphan(proof, true);
-            numOrphans++;
-        }
+    for (const auto &proof : orphans) {
+        checkOrphan(proof, false);
     }
-    BOOST_CHECK_EQUAL(numOrphans, AVALANCHE_MAX_ORPHAN_PROOFS);
 }
 
 BOOST_AUTO_TEST_CASE(dangling_node) {
@@ -1017,7 +912,7 @@
 
     pm.updatedBlockTip();
 
-    BOOST_CHECK(pm.isOrphan(proofToInvalidate->getId()));
+    BOOST_CHECK(!pm.exists(proofToInvalidate->getId()));
 
     BOOST_CHECK(!pm.isInConflictingPool(conflictingProof->getId()));
     BOOST_CHECK(pm.isBoundToPeer(conflictingProof->getId()));
@@ -1113,16 +1008,17 @@
 }
 
 BOOST_AUTO_TEST_CASE(conflicting_orphans) {
+    gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "2");
     avalanche::PeerManager pm(*m_node.scheduler);
 
     const CKey key = CKey::MakeCompressedKey();
 
-    const COutPoint conflictingOutpoint(TxId(GetRandHash()), 0);
-    const COutPoint randomOutpoint1(TxId(GetRandHash()), 0);
+    const COutPoint conflictingOutpoint = createUtxo(key);
+    const COutPoint matureOutpoint = createUtxo(key, 10 * COIN, 99);
 
     auto orphan10 = buildProofWithSequence(key, {conflictingOutpoint}, 10);
     auto orphan20 =
-        buildProofWithSequence(key, {conflictingOutpoint, randomOutpoint1}, 20);
+        buildProofWithSequence(key, {conflictingOutpoint, matureOutpoint}, 20);
 
     BOOST_CHECK(!pm.registerProof(orphan10));
     BOOST_CHECK(pm.isOrphan(orphan10->getId()));
@@ -1131,23 +1027,18 @@
     BOOST_CHECK(pm.isOrphan(orphan20->getId()));
     BOOST_CHECK(!pm.exists(orphan10->getId()));
 
-    const COutPoint outpointToSend(TxId(GetRandHash()), 0);
-    // Add both randomOutpoint1 and outpointToSend to the UTXO set. The orphan20
-    // proof is still an orphan because the conflictingOutpoint is unknown.
-    addCoin(randomOutpoint1, key);
-    addCoin(outpointToSend, key);
-
-    // Build and register proof valid proof that will conflict with the orphan
+    // Build and register a valid proof that will conflict with the orphan
     auto proof30 =
-        buildProofWithSequence(key, {randomOutpoint1, outpointToSend}, 30);
+        buildProofWithOutpoints(key, {matureOutpoint}, 10 * COIN, key, 30, 99);
     BOOST_CHECK(pm.registerProof(proof30));
     BOOST_CHECK(pm.isBoundToPeer(proof30->getId()));
 
-    // Spend the outpointToSend to orphan proof30
+    // Reorg to a shorter chain to orphan proof30
     {
-        LOCK(cs_main);
-        CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
-        coins.SpendCoin(outpointToSend);
+        BlockValidationState state;
+        ::ChainstateActive().InvalidateBlock(GetConfig(), state,
+                                             ::ChainActive().Tip());
+        BOOST_CHECK_EQUAL(::ChainActive().Height(), 99);
     }
 
     // Check that a rescan will also select the preferred orphan, in this case
@@ -1386,17 +1277,21 @@
 }
 
 BOOST_FIXTURE_TEST_CASE(reject_proof, NoCoolDownFixture) {
+    gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "2");
     avalanche::PeerManager pm(*m_node.scheduler);
 
     const CKey key = CKey::MakeCompressedKey();
 
-    const COutPoint conflictingOutpoint = createUtxo(key);
+    const COutPoint conflictingOutpoint = createUtxo(key, 10 * COIN, 99);
+    const COutPoint immatureOutpoint = createUtxo(key);
 
     // The good, the bad and the ugly
-    auto proofSeq10 = buildProofWithSequence(key, {conflictingOutpoint}, 10);
-    auto proofSeq20 = buildProofWithSequence(key, {conflictingOutpoint}, 20);
+    auto proofSeq10 = buildProofWithOutpoints(key, {conflictingOutpoint},
+                                              10 * COIN, key, 10, 99);
+    auto proofSeq20 = buildProofWithOutpoints(key, {conflictingOutpoint},
+                                              10 * COIN, key, 20, 99);
     auto orphan30 = buildProofWithSequence(
-        key, {conflictingOutpoint, {TxId(GetRandHash()), 0}}, 30);
+        key, {conflictingOutpoint, immatureOutpoint}, 30);
 
     BOOST_CHECK(pm.registerProof(proofSeq20));
     BOOST_CHECK(!pm.registerProof(proofSeq10));
diff --git a/src/avalanche/test/processor_tests.cpp b/src/avalanche/test/processor_tests.cpp
--- a/src/avalanche/test/processor_tests.cpp
+++ b/src/avalanche/test/processor_tests.cpp
@@ -1133,6 +1133,7 @@
 }
 
 BOOST_AUTO_TEST_CASE(proof_record) {
+    gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "2");
     gArgs.ForceSetArg("-avalancheconflictingproofcooldown", "0");
 
     BOOST_CHECK(!m_processor->isAccepted(nullptr));
@@ -1141,6 +1142,7 @@
     const CKey key = CKey::MakeCompressedKey();
 
     const COutPoint conflictingOutpoint{TxId(GetRandHash()), 0};
+    const COutPoint immatureOutpoint{TxId(GetRandHash()), 0};
     {
         CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
 
@@ -1148,18 +1150,20 @@
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.AddCoin(conflictingOutpoint,
                       Coin(CTxOut(10 * COIN, script), 10, false), false);
+        coins.AddCoin(immatureOutpoint,
+                      Coin(CTxOut(10 * COIN, script), 100, false), false);
     }
-    const COutPoint missingOutpoint{TxId(GetRandHash()), 0};
 
-    auto buildProof = [&](const COutPoint &outpoint, uint64_t sequence) {
+    auto buildProof = [&](const COutPoint &outpoint, uint64_t sequence,
+                          uint32_t height = 10) {
         ProofBuilder pb(sequence, 0, key);
-        BOOST_CHECK(pb.addUTXO(outpoint, 10 * COIN, 10, false, key));
+        BOOST_CHECK(pb.addUTXO(outpoint, 10 * COIN, height, false, key));
         return pb.build();
     };
 
     auto conflictingProof = buildProof(conflictingOutpoint, 1);
     auto validProof = buildProof(conflictingOutpoint, 2);
-    auto orphanProof = buildProof(missingOutpoint, 3);
+    auto orphanProof = buildProof(immatureOutpoint, 3, 100);
 
     BOOST_CHECK(!m_processor->isAccepted(conflictingProof));
     BOOST_CHECK(!m_processor->isAccepted(validProof));
@@ -1207,6 +1211,7 @@
     BOOST_CHECK_EQUAL(m_processor->getConfidence(validProof), 0);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(orphanProof), -1);
 
+    gArgs.ClearForcedArg("-avaproofstakeutxoconfirmations");
     gArgs.ClearForcedArg("-avalancheconflictingproofcooldown");
 }
 
@@ -1292,9 +1297,8 @@
     });
     BOOST_CHECK(processor->isQuorumEstablished());
 
-    // Remove peers one at a time by orphaning their proofs, and ensure the
-    // quorum stays established
-    auto orphanProof = [&processor](ProofRef proof) {
+    // Remove peers one at a time and ensure the quorum stays established
+    auto spendProofUtxo = [&processor](ProofRef proof) {
         {
             LOCK(cs_main);
             CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
@@ -1302,26 +1306,25 @@
         }
         processor->withPeerManager([&proof](avalanche::PeerManager &pm) {
             pm.updatedBlockTip();
-            BOOST_CHECK(pm.isOrphan(proof->getId()));
             BOOST_CHECK(!pm.isBoundToPeer(proof->getId()));
         });
     };
 
-    orphanProof(proof2);
+    spendProofUtxo(proof2);
     processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), 3 * minScore / 4);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), 0);
     });
     BOOST_CHECK(processor->isQuorumEstablished());
 
-    orphanProof(proof1);
+    spendProofUtxo(proof1);
     processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), minScore / 4);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), 0);
     });
     BOOST_CHECK(processor->isQuorumEstablished());
 
-    orphanProof(processor->getLocalProof());
+    spendProofUtxo(processor->getLocalProof());
     processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), 0);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), 0);
diff --git a/test/functional/abc_p2p_avalanche_peer_discovery.py b/test/functional/abc_p2p_avalanche_peer_discovery.py
--- a/test/functional/abc_p2p_avalanche_peer_discovery.py
+++ b/test/functional/abc_p2p_avalanche_peer_discovery.py
@@ -40,7 +40,7 @@
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.extra_args = [['-enableavalanche=1',
-                            '-avaproofstakeutxoconfirmations=1',
+                            '-avaproofstakeutxoconfirmations=3',
                             '-enableavalanchepeerdiscovery=1']]
         self.supports_cli = False
 
@@ -61,7 +61,7 @@
 
         # Create stakes by mining blocks
         addrkey0 = node.get_deterministic_priv_key()
-        blockhashes = node.generatetoaddress(2, addrkey0.address)
+        blockhashes = node.generatetoaddress(4, addrkey0.address)
         stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
 
         proof_sequence = 11
@@ -194,6 +194,9 @@
         new_proof = new_proof_obj.serialize().hex()
         new_proofid = new_proof_obj.proofid
 
+        # Make the proof mature
+        node.generate(2)
+
         node.sendavalancheproof(new_proof)
         wait_for_proof(node, f"{new_proofid:0{64}x}")
 
@@ -259,8 +262,8 @@
 
         self.log.info("Invalidate the proof and check the nodes are removed")
         tip = node.getbestblockhash()
-        # Invalidate the block with the proof utxo
-        node.invalidateblock(blockhashes[1])
+        # Invalidate the block after the proof utxo to make the proof immature
+        node.invalidateblock(blockhashes[2])
         # Change the address to make sure we don't generate a block identical
         # to the one we just invalidated. Can be generate(1) after D9694 or
         # D9697 is landed.
diff --git a/test/functional/abc_p2p_avalanche_proof_voting.py b/test/functional/abc_p2p_avalanche_proof_voting.py
--- a/test/functional/abc_p2p_avalanche_proof_voting.py
+++ b/test/functional/abc_p2p_avalanche_proof_voting.py
@@ -39,7 +39,7 @@
         self.extra_args = [
             ['-enableavalanche=1',
              '-enableavalancheproofreplacement=1',
-             '-avaproofstakeutxoconfirmations=1',
+             '-avaproofstakeutxoconfirmations=2',
                 f'-avalancheconflictingproofcooldown={self.conflicting_proof_cooldown}', f'-avalanchepeerreplacementcooldown={self.peer_replacement_cooldown}', '-avacooldown=0', '-avastalevotethreshold=140', '-avastalevotefactor=1'],
         ]
         self.supports_cli = False
@@ -106,12 +106,17 @@
         self.privkey, self.quorum_proof = gen_proof(node)
         self.privkey_wif = bytes_to_wif(self.privkey.get_bytes())
 
+        # Make the quorum proof mature before preparing the quorum
+        node.generate(1)
+
         self.quorum = self.get_quorum(node)
 
         addrkey0 = node.get_deterministic_priv_key()
         blockhash = node.generatetoaddress(10, addrkey0.address)
         self.conflicting_stakes = create_coinbase_stakes(
-            node, blockhash[5:], addrkey0.key)
+            node, blockhash[5:9], addrkey0.key)
+        self.immature_stakes = create_coinbase_stakes(
+            node, blockhash[9:], addrkey0.key)
 
         self.poll_tests(node)
         self.update_tests(node)
@@ -126,15 +131,7 @@
         proof_seq40 = self.build_conflicting_proof(node, 40)
 
         orphan = node.buildavalancheproof(
-            100, 2000000000, self.privkey_wif, [{
-                'txid': '0' * 64,
-                'vout': 0,
-                'amount': 10e6,
-                'height': 42,
-                'iscoinbase': False,
-                'privatekey': self.privkey_wif,
-            }]
-        )
+            100, 0, self.privkey_wif, self.immature_stakes)
 
         no_stake = node.buildavalancheproof(
             200, 2000000000, self.privkey_wif, []
@@ -310,7 +307,7 @@
 
     def vote_tests(self, node):
         self.restart_node(0, extra_args=['-enableavalanche=1',
-                                         '-avaproofstakeutxoconfirmations=1',
+                                         '-avaproofstakeutxoconfirmations=2',
                                          '-avacooldown=0',
                                          '-avalancheconflictingproofcooldown=0',
                                          '-whitelist=noban@127.0.0.1', ])
@@ -338,9 +335,8 @@
         stakes_1 = create_coinbase_stakes(node, [blocks[1]], stakes_key.key)
         proof_1, proof_1_id = create_proof(stakes_1)
 
-        # proof_2 is an orphan because the stake UTXO is unknown
-        stakes_2 = create_coinbase_stakes(node, [blocks[2]], stakes_key.key)
-        stakes_2[0]['height'] = 5
+        # proof_2 is an orphan because the stake UTXO is immature
+        stakes_2 = create_coinbase_stakes(node, [blocks[3]], stakes_key.key)
         proof_2, proof_2_id = create_proof(stakes_2)
 
         # proof_3 conflicts with proof_0 and proof_1
@@ -349,7 +345,7 @@
         proof_3, proof_3_id = create_proof(stakes_3)
 
         # proof_4 is invalid and should be rejected
-        stakes_4 = create_coinbase_stakes(node, [blocks[3]], stakes_key.key)
+        stakes_4 = create_coinbase_stakes(node, [blocks[2]], stakes_key.key)
         stakes_4[0]['amount'] -= 100000
         proof_4, proof_4_id = create_proof(stakes_4)
 
diff --git a/test/functional/abc_p2p_proof_inventory.py b/test/functional/abc_p2p_proof_inventory.py
--- a/test/functional/abc_p2p_proof_inventory.py
+++ b/test/functional/abc_p2p_proof_inventory.py
@@ -9,13 +9,7 @@
 import time
 
 from test_framework.address import ADDRESS_ECREG_UNSPENDABLE
-from test_framework.avatools import (
-    avalanche_proof_from_hex,
-    gen_proof,
-    get_proof_ids,
-    wait_for_proof,
-)
-from test_framework.key import ECKey
+from test_framework.avatools import gen_proof, get_proof_ids, wait_for_proof
 from test_framework.messages import (
     MSG_AVA_PROOF,
     MSG_TYPE_MASK,
@@ -25,7 +19,11 @@
 )
 from test_framework.p2p import P2PInterface, p2p_lock
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, assert_greater_than
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than,
+    assert_raises_rpc_error,
+)
 from test_framework.wallet_util import bytes_to_wif
 
 # Broadcast reattempt occurs every 10 to 15 minutes
@@ -50,11 +48,19 @@
         self.num_nodes = 5
         self.extra_args = [[
             '-enableavalanche=1',
-            '-avaproofstakeutxoconfirmations=1',
+            '-avaproofstakeutxoconfirmations=2',
             '-avacooldown=0',
             '-whitelist=noban@127.0.0.1',
         ]] * self.num_nodes
 
+    def generate_proof(self, node, mature=True):
+        privkey, proof = gen_proof(node)
+
+        if mature:
+            node.generate(1)
+
+        return privkey, proof
+
     def test_send_proof_inv(self):
         self.log.info("Test sending a proof to our peers")
 
@@ -63,7 +69,7 @@
         for i in range(10):
             node.add_p2p_connection(ProofInvStoreP2PInterface())
 
-        _, proof = gen_proof(node)
+        _, proof = self.generate_proof(node)
         assert node.sendavalancheproof(proof.serialize().hex())
 
         def proof_inv_found(peer):
@@ -96,7 +102,7 @@
         self.log.info("Test a peer is created on proof reception")
 
         node = self.nodes[0]
-        _, proof = gen_proof(node)
+        _, proof = self.generate_proof(node)
 
         peer = node.add_p2p_connection(P2PInterface())
 
@@ -106,22 +112,10 @@
 
         self.wait_until(lambda: proof.proofid in get_proof_ids(node))
 
-        self.log.info("Test receiving a proof with missing utxo is orphaned")
-
-        privkey = ECKey()
-        privkey.generate()
-        orphan_hex = node.buildavalancheproof(
-            42, 2000000000, bytes_to_wif(privkey.get_bytes()), [{
-                'txid': '0' * 64,
-                'vout': 0,
-                'amount': 10e6,
-                'height': 42,
-                'iscoinbase': False,
-                'privatekey': bytes_to_wif(privkey.get_bytes()),
-            }]
-        )
+        self.log.info(
+            "Test receiving a proof with an immature utxo is orphaned")
 
-        orphan = avalanche_proof_from_hex(orphan_hex)
+        _, orphan = self.generate_proof(node, mature=False)
         orphan_proofid = "{:064x}".format(orphan.proofid)
 
         msg = msg_avaproof()
@@ -132,7 +126,7 @@
 
     def test_ban_invalid_proof(self):
         node = self.nodes[0]
-        _, bad_proof = gen_proof(node)
+        _, bad_proof = self.generate_proof(node)
         bad_proof.stakes = []
 
         self.restart_node(0, ['-enableavalanche=1'])
@@ -151,28 +145,32 @@
     def test_proof_relay(self):
         # This test makes no sense with a single node !
         assert_greater_than(self.num_nodes, 1)
+        node = self.nodes[0]
 
         def restart_nodes_with_proof(nodes=self.nodes):
-            proofids = set()
-            for i, node in enumerate(nodes):
-                privkey, proof = gen_proof(node)
-                proofids.add(proof.proofid)
+            proofs = []
+            for i in range(self.num_nodes):
+                proofs.append(self.generate_proof(self.nodes[0]))
+            self.sync_all()
 
+            # Restart nodes with new proofs
+            for i, node in enumerate(nodes):
+                privkey, proof = proofs[i]
                 self.restart_node(node.index, self.extra_args[node.index] + [
                     "-avaproof={}".format(proof.serialize().hex()),
                     "-avamasterkey={}".format(bytes_to_wif(privkey.get_bytes()))
                 ])
 
-                # Connect a block to make the proof be added to our pool
-                node.generate(1)
-                self.wait_until(lambda: proof.proofid in get_proof_ids(node))
-
                 [self.connect_nodes(node.index, j) for j in range(node.index)]
 
-            return proofids
+            return set(proof.proofid for _, proof in proofs)
 
         proofids = restart_nodes_with_proof(self.nodes)
 
+        # Connect a block to make the proofs added to our pool
+        node.generate(1)
+        self.sync_all()
+
         self.log.info("Nodes should eventually get the proof from their peer")
         self.sync_proofs()
         for node in self.nodes:
@@ -181,7 +179,7 @@
     def test_manually_sent_proof(self):
         node0 = self.nodes[0]
 
-        _, proof = gen_proof(node0)
+        _, proof = self.generate_proof(node0)
 
         self.log.info(
             "Send a proof via RPC and check all the nodes download it")
@@ -206,7 +204,7 @@
                 peers.append(peer)
             return peers
 
-        _, proof = gen_proof(node)
+        _, proof = self.generate_proof(node)
         proofid_hex = "{:064x}".format(proof.proofid)
 
         # Broadcast the proof
@@ -275,9 +273,17 @@
         # Mine the tx in a block
         node.generate(1)
 
-        # Wait for the proof to be orphaned
-        self.wait_until(lambda: node.getrawavalancheproof(
-            proofid_hex)["orphan"] is True)
+        # Wait for the proof to be invalidated
+        def check_proof_not_found(proofid):
+            try:
+                assert_raises_rpc_error(-8,
+                                        "Proof not found",
+                                        node.getrawavalancheproof,
+                                        proofid)
+                return True
+            except BaseException:
+                return False
+        self.wait_until(lambda: check_proof_not_found(proofid_hex))
 
         # It should no longer be broadcasted
         peers = add_peers(3)
diff --git a/test/functional/abc_rpc_avalancheproof.py b/test/functional/abc_rpc_avalancheproof.py
--- a/test/functional/abc_rpc_avalancheproof.py
+++ b/test/functional/abc_rpc_avalancheproof.py
@@ -56,7 +56,7 @@
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [
-            ['-enableavalanche=1', "-avaproofstakeutxoconfirmations=1", '-avacooldown=0', '-legacyavaproof=1']] * self.num_nodes
+            ['-enableavalanche=1', '-avaproofstakeutxoconfirmations=1', '-avacooldown=0', '-legacyavaproof=1']] * self.num_nodes
         self.supports_cli = False
         self.rpc_timeout = 120
 
@@ -204,18 +204,21 @@
         # transactions used for stakes.
         self.log.info("Start a node with an orphan proof")
 
-        self.start_node(1, self.extra_args[0] + [
+        stake_age = node.getblockcount() + 2
+        self.restart_node(1, self.extra_args[0] + [
+            "-avaproofstakeutxoconfirmations={}".format(stake_age),
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
         ])
         # Mine a block to trigger an attempt at registering the proof
+        self.connect_nodes(1, node.index)
+        self.sync_all()
         self.nodes[1].generate(1)
         wait_for_proof(self.nodes[1], proofid_hex, expect_orphan=True)
 
-        self.log.info("Connect to an up-to-date node to unorphan the proof")
-        self.connect_nodes(1, node.index)
-        self.sync_all()
-        wait_for_proof(self.nodes[1], proofid_hex, expect_orphan=False)
+        # Mine another block to make the orphan mature
+        self.nodes[1].generate(1)
+        wait_for_proof(self.nodes[0], proofid_hex, expect_orphan=False)
 
         self.log.info(
             "Generate delegations for the proof, verify and decode them")
@@ -404,8 +407,10 @@
             node.generate(101)
             too_many_stakes = create_stakes(
                 node, new_blocks, AVALANCHE_MAX_PROOF_STAKES + 1)
-            maximum_stakes = too_many_stakes[:-1]
+            # Make the newly split UTXOs mature
+            node.generate(stake_age)
 
+            maximum_stakes = too_many_stakes[:-1]
             good_proof = node.buildavalancheproof(
                 proof_sequence, proof_expiration,
                 wif_privkey, maximum_stakes)
@@ -441,7 +446,10 @@
                                     node.sendavalancheproof, conflicting_utxo)
 
         # Clear the proof pool
-        self.restart_node(0)
+        stake_age = node.getblockcount()
+        self.restart_node(0, self.extra_args[0] + [
+            "-avaproofstakeutxoconfirmations={}".format(stake_age),
+        ])
 
         # Good proof
         assert node.verifyavalancheproof(proof)
@@ -468,16 +476,18 @@
         assert_raises_rpc_error(-8, "Proof not found",
                                 node.getrawavalancheproof, '0' * 64)
 
-        # Orphan the proof by sending the stake
-        raw_tx = node.createrawtransaction(
-            [{"txid": stakes[-1]["txid"], "vout": 0}],
-            {ADDRESS_ECREG_UNSPENDABLE: stakes[-1]
-                ["amount"] - Decimal('10000')}
-        )
-        signed_tx = node.signrawtransactionwithkey(raw_tx, [addrkey0.key])
-        node.sendrawtransaction(signed_tx["hex"])
+        # To orphan the proof, we make it immature by switching to a shorter
+        # chain
+        node.invalidateblock(node.getbestblockhash())
+        # Although the chaintip has changed, updatedBlockTip does not get
+        # called unless new chainwork needs evaluating, so invalidate another
+        # block and then mine a new one.
+        node.invalidateblock(node.getbestblockhash())
+        node.setmocktime(
+            node.getblock(
+                node.getbestblockhash())['mediantime'] +
+            100)
         node.generate(1)
-        self.wait_until(lambda: proofid not in get_proof_ids(node))
 
         raw_proof = node.getrawavalancheproof("{:064x}".format(proofid))
         assert_equal(raw_proof['proof'], proof)
diff --git a/test/functional/p2p_inv_download.py b/test/functional/p2p_inv_download.py
--- a/test/functional/p2p_inv_download.py
+++ b/test/functional/p2p_inv_download.py
@@ -10,7 +10,11 @@
 import time
 
 from test_framework.address import ADDRESS_ECREG_UNSPENDABLE
-from test_framework.avatools import avalanche_proof_from_hex, wait_for_proof
+from test_framework.avatools import (
+    avalanche_proof_from_hex,
+    gen_proof,
+    wait_for_proof,
+)
 from test_framework.key import ECKey
 from test_framework.messages import (
     MSG_AVA_PROOF,
@@ -376,33 +380,22 @@
     @skip(TX_TEST_CONTEXT)
     def test_orphan_download(self, context):
         node = self.nodes[0]
-        privkey = ECKey()
-        privkey.generate()
-        privkey_wif = bytes_to_wif(privkey.get_bytes())
-
-        # Build a proof with missing utxos so it will be orphaned
-        orphan = node.buildavalancheproof(
-            42, 2000000000, bytes_to_wif(privkey.get_bytes()), [{
-                'txid': '0' * 64,
-                'vout': 0,
-                'amount': 10e6,
-                'height': 42,
-                'iscoinbase': False,
-                'privatekey': privkey_wif,
-            }]
-        )
-        proofid = avalanche_proof_from_hex(orphan).proofid
-        proofid_hex = "{:064x}".format(proofid)
+
+        # Build a proof with immature utxos so it will be orphaned
+        privkey, orphan = gen_proof(node)
+        proofid_hex = "{:064x}".format(orphan.proofid)
 
         self.restart_node(0, extra_args=self.extra_args[0] + [
-            "-avaproof={}".format(orphan),
-            "-avamasterkey={}".format(privkey_wif),
+            "-avaproofstakeutxoconfirmations=3",
+            "-avaproof={}".format(orphan.serialize().hex()),
+            "-avamasterkey={}".format(bytes_to_wif(privkey.get_bytes())),
         ])
         node.generate(1)
         wait_for_proof(node, proofid_hex, expect_orphan=True)
 
         peer = node.add_p2p_connection(context.p2p_conn())
-        peer.send_message(msg_inv([CInv(t=context.inv_type, h=proofid)]))
+        peer.send_message(
+            msg_inv([CInv(t=context.inv_type, h=orphan.proofid)]))
 
         # Give enough time for the node to eventually request the proof.
         node.setmocktime(int(time.time()) +