diff --git a/src/avalanche/processor.h b/src/avalanche/processor.h
--- a/src/avalanche/processor.h
+++ b/src/avalanche/processor.h
@@ -171,7 +171,7 @@
     }
 
     bool addBlockToReconcile(const CBlockIndex *pindex);
-    void addProofToReconcile(const ProofRef &proof, bool isAccepted);
+    void addProofToReconcile(const ProofRef &proof);
     bool isAccepted(const CBlockIndex *pindex) const;
     bool isAccepted(const ProofRef &proof) const;
     int getConfidence(const CBlockIndex *pindex) const;
diff --git a/src/avalanche/processor.cpp b/src/avalanche/processor.cpp
--- a/src/avalanche/processor.cpp
+++ b/src/avalanche/processor.cpp
@@ -261,10 +261,13 @@
         .second;
 }
 
-void Processor::addProofToReconcile(const ProofRef &proof, bool isAccepted) {
+void Processor::addProofToReconcile(const ProofRef &proof) {
     // TODO We don't want to accept an infinite number of conflicting proofs.
     // They should be some rules to make them expensive and/or limited by
     // design.
+    const bool isAccepted =
+        WITH_LOCK(cs_peerManager, return peerManager->isValid(proof->getId()));
+
     proofVoteRecords.getWriteView()->insert(
         std::make_pair(proof, VoteRecord(isAccepted)));
 }
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
@@ -245,7 +245,13 @@
     ProofProvider(AvalancheTestingSetup *_fixture)
         : fixture(_fixture), invType(MSG_AVA_PROOF) {}
 
-    ProofRef buildVoteItem() const { return fixture->GetProof(); }
+    ProofRef buildVoteItem() const {
+        const ProofRef proof = fixture->GetProof();
+        fixture->m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
+            BOOST_CHECK(pm.registerProof(proof));
+        });
+        return proof;
+    }
 
     uint256 getVoteItemId(const ProofRef &proof) const {
         return proof->getId();
@@ -264,7 +270,7 @@
     }
 
     bool addToReconcile(const ProofRef &proof) {
-        fixture->m_processor->addProofToReconcile(proof, true);
+        fixture->m_processor->addProofToReconcile(proof);
         return true;
     }
 
@@ -1109,7 +1115,7 @@
 
     auto addProofToReconcile = [&](uint32_t proofScore) {
         auto proof = buildRandomProof(proofScore);
-        m_processor->addProofToReconcile(proof, GetRandInt(1));
+        m_processor->addProofToReconcile(proof);
         return proof;
     };
 
@@ -1123,7 +1129,7 @@
     }
 
     // From here a new proof is only polled if its score is in the top
-    // AVALANCHE_MAX_ELEMENT_POLL - 1
+    // AVALANCHE_MAX_ELEMENT_POLL
     ProofId lastProofId;
     for (size_t i = 0; i < 10; i++) {
         auto proof = addProofToReconcile(++score);
@@ -1165,13 +1171,16 @@
     BOOST_CHECK_EQUAL(m_processor->getConfidence(proofA), -1);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(proofB), -1);
 
-    m_processor->addProofToReconcile(proofA, false);
+    m_processor->addProofToReconcile(proofA);
     BOOST_CHECK(!m_processor->isAccepted(proofA));
     BOOST_CHECK(!m_processor->isAccepted(proofB));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(proofA), 0);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(proofB), -1);
 
-    m_processor->addProofToReconcile(proofB, true);
+    m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
+        BOOST_CHECK(pm.registerProof(proofB));
+    });
+    m_processor->addProofToReconcile(proofB);
     BOOST_CHECK(!m_processor->isAccepted(proofA));
     BOOST_CHECK(m_processor->isAccepted(proofB));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(proofA), 0);