diff --git a/src/avalanche/peermanager.h b/src/avalanche/peermanager.h
--- a/src/avalanche/peermanager.h
+++ b/src/avalanche/peermanager.h
@@ -90,6 +90,12 @@
     std::chrono::seconds registration_time;
     std::chrono::seconds nextPossibleConflictTime;
 
+    /**
+     * Consider dropping the peer if no node is attached after this timeout
+     * expired.
+     */
+    static constexpr auto DANGLING_TIMEOUT = 15min;
+
     Peer(PeerId peerid_, ProofRef proof_,
          std::chrono::seconds nextPossibleConflictTime_)
         : peerid(peerid_), proof(std::move(proof_)),
@@ -388,6 +394,8 @@
     bool addNodeToPeer(const PeerSet::iterator &it);
     bool removeNodeFromPeer(const PeerSet::iterator &it, uint32_t count = 1);
 
+    void cleanupDanglingProofs();
+
     friend struct ::avalanche::TestPeerManager;
 };
 
diff --git a/src/avalanche/peermanager.cpp b/src/avalanche/peermanager.cpp
--- a/src/avalanche/peermanager.cpp
+++ b/src/avalanche/peermanager.cpp
@@ -784,4 +784,22 @@
     m_unbroadcast_proofids.erase(proofid);
 }
 
+void PeerManager::cleanupDanglingProofs() {
+    const auto now = GetTime<std::chrono::seconds>();
+
+    std::vector<ProofId> danglingProofIds;
+    for (const Peer &peer : peers) {
+        // If the peer has been registered for some time and has no node
+        // attached, discard it.
+        if (peer.node_count == 0 &&
+            (peer.registration_time + Peer::DANGLING_TIMEOUT) <= now) {
+            danglingProofIds.push_back(peer.getProofId());
+        }
+    }
+
+    for (const ProofId &proofid : danglingProofIds) {
+        rejectProof(proofid, RejectionMode::INVALIDATE);
+    }
+}
+
 } // namespace avalanche
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
@@ -56,6 +56,10 @@
 
             return scores;
         }
+
+        static void cleanupDanglingProofs(PeerManager &pm) {
+            pm.cleanupDanglingProofs();
+        }
     };
 
     static void addCoin(const COutPoint &outpoint, const CKey &key,
@@ -1836,4 +1840,141 @@
     }
 }
 
+BOOST_FIXTURE_TEST_CASE(cleanup_dangling_proof, NoCoolDownFixture) {
+    gArgs.ForceSetArg("-enableavalancheproofreplacement", "1");
+
+    avalanche::PeerManager pm;
+
+    const auto now = GetTime<std::chrono::seconds>();
+    auto mocktime = now;
+
+    auto elapseTime = [&](std::chrono::seconds seconds) {
+        mocktime += seconds;
+        SetMockTime(mocktime.count());
+    };
+    elapseTime(0s);
+
+    const CKey key = CKey::MakeCompressedKey();
+
+    const size_t numProofs = 10;
+
+    std::vector<COutPoint> outpoints(numProofs);
+    std::vector<ProofRef> proofs(numProofs);
+    std::vector<ProofRef> conflictingProofs(numProofs);
+    for (size_t i = 0; i < numProofs; i++) {
+        outpoints[i] = createUtxo(key);
+        proofs[i] = buildProofWithSequence(key, {outpoints[i]}, 2);
+        conflictingProofs[i] = buildProofWithSequence(key, {outpoints[i]}, 1);
+
+        BOOST_CHECK(pm.registerProof(proofs[i]));
+        BOOST_CHECK(pm.isBoundToPeer(proofs[i]->getId()));
+
+        BOOST_CHECK(!pm.registerProof(conflictingProofs[i]));
+        BOOST_CHECK(pm.isInConflictingPool(conflictingProofs[i]->getId()));
+
+        if (i % 2) {
+            // Odd indexes get a node attached to them
+            BOOST_CHECK(pm.addNode(i, proofs[i]->getId()));
+        }
+        BOOST_CHECK_EQUAL(pm.forPeer(proofs[i]->getId(),
+                                     [&](const avalanche::Peer &peer) {
+                                         return peer.node_count;
+                                     }),
+                          i % 2);
+
+        elapseTime(1s);
+    }
+
+    // No proof expired yet
+    TestPeerManager::cleanupDanglingProofs(pm);
+    for (size_t i = 0; i < numProofs; i++) {
+        BOOST_CHECK(pm.isBoundToPeer(proofs[i]->getId()));
+        BOOST_CHECK(pm.isInConflictingPool(conflictingProofs[i]->getId()));
+    }
+
+    // Elapse the dangling timeout
+    elapseTime(avalanche::Peer::DANGLING_TIMEOUT);
+    TestPeerManager::cleanupDanglingProofs(pm);
+    for (size_t i = 0; i < numProofs; i++) {
+        const bool hasNodeAttached = i % 2;
+
+        // Only the peers with no nodes attached are getting discarded
+        BOOST_CHECK_EQUAL(pm.isBoundToPeer(proofs[i]->getId()),
+                          hasNodeAttached);
+        BOOST_CHECK_EQUAL(!pm.exists(proofs[i]->getId()), !hasNodeAttached);
+
+        // The proofs conflicting with the discarded ones are pulled back
+        BOOST_CHECK_EQUAL(pm.isInConflictingPool(conflictingProofs[i]->getId()),
+                          hasNodeAttached);
+        BOOST_CHECK_EQUAL(pm.isBoundToPeer(conflictingProofs[i]->getId()),
+                          !hasNodeAttached);
+    }
+
+    // Attach a node to the first conflicting proof, which has been promoted
+    BOOST_CHECK(pm.addNode(42, conflictingProofs[0]->getId()));
+    BOOST_CHECK(pm.forPeer(
+        conflictingProofs[0]->getId(),
+        [&](const avalanche::Peer &peer) { return peer.node_count == 1; }));
+
+    // Elapse the dangling timeout again
+    elapseTime(avalanche::Peer::DANGLING_TIMEOUT);
+    TestPeerManager::cleanupDanglingProofs(pm);
+    for (size_t i = 0; i < numProofs; i++) {
+        const bool hasNodeAttached = i % 2;
+
+        // The initial peers with a node attached are still there
+        BOOST_CHECK_EQUAL(pm.isBoundToPeer(proofs[i]->getId()),
+                          hasNodeAttached);
+        BOOST_CHECK_EQUAL(!pm.exists(proofs[i]->getId()), !hasNodeAttached);
+
+        // This time the previouly promoted conflicting proofs are evicted
+        // because they have no node attached, except the index 0.
+        BOOST_CHECK_EQUAL(pm.exists(conflictingProofs[i]->getId()),
+                          hasNodeAttached || i == 0);
+        BOOST_CHECK_EQUAL(pm.isInConflictingPool(conflictingProofs[i]->getId()),
+                          hasNodeAttached);
+        BOOST_CHECK_EQUAL(pm.isBoundToPeer(conflictingProofs[i]->getId()),
+                          i == 0);
+    }
+
+    // Disconnect all the nodes
+    for (size_t i = 1; i < numProofs; i += 2) {
+        BOOST_CHECK(pm.removeNode(i));
+        BOOST_CHECK(
+            pm.forPeer(proofs[i]->getId(), [&](const avalanche::Peer &peer) {
+                return peer.node_count == 0;
+            }));
+    }
+    BOOST_CHECK(pm.removeNode(42));
+    BOOST_CHECK(pm.forPeer(
+        conflictingProofs[0]->getId(),
+        [&](const avalanche::Peer &peer) { return peer.node_count == 0; }));
+
+    TestPeerManager::cleanupDanglingProofs(pm);
+    for (size_t i = 0; i < numProofs; i++) {
+        const bool hadNodeAttached = i % 2;
+
+        // All initially valid proofs have now been discarded
+        BOOST_CHECK(!pm.exists(proofs[i]->getId()));
+
+        // The remaining conflicting proofs are promoted
+        BOOST_CHECK_EQUAL(!pm.exists(conflictingProofs[i]->getId()),
+                          !hadNodeAttached);
+        BOOST_CHECK(!pm.isInConflictingPool(conflictingProofs[i]->getId()));
+        BOOST_CHECK_EQUAL(pm.isBoundToPeer(conflictingProofs[i]->getId()),
+                          hadNodeAttached);
+    }
+
+    // Elapse the timeout for the newly promoted conflicting proofs
+    elapseTime(avalanche::Peer::DANGLING_TIMEOUT);
+    TestPeerManager::cleanupDanglingProofs(pm);
+    for (size_t i = 0; i < numProofs; i++) {
+        // All proofs have now been discarded
+        BOOST_CHECK(!pm.exists(proofs[i]->getId()));
+        BOOST_CHECK(!pm.exists(conflictingProofs[i]->getId()));
+    }
+
+    gArgs.ClearForcedArg("-enableavalancheproofreplacement");
+}
+
 BOOST_AUTO_TEST_SUITE_END()