diff --git a/src/avalanche/peermanager.h b/src/avalanche/peermanager.h
--- a/src/avalanche/peermanager.h
+++ b/src/avalanche/peermanager.h
@@ -75,12 +75,12 @@
 
     std::shared_ptr<Proof> proof;
 
-    using Timestamp = std::chrono::time_point<std::chrono::system_clock>;
-    Timestamp time;
+    // The network stack uses timestamp in seconds, so we oblige.
+    std::chrono::seconds registration_time;
 
     Peer(PeerId peerid_, std::shared_ptr<Proof> proof_)
         : peerid(peerid_), proof(std::move(proof_)),
-          time(std::chrono::seconds(GetTime())) {}
+          registration_time(GetTime<std::chrono::seconds>()) {}
 
     const ProofId &getProofId() const { return proof->getId(); }
     uint32_t getScore() const { return proof->getScore(); }
@@ -199,7 +199,7 @@
     std::vector<NodeId> getNodeIdsForPeer(PeerId peerId) const;
 
     std::shared_ptr<Proof> getProof(const ProofId &proofid) const;
-    Peer::Timestamp getProofTime(const ProofId &proofid) const;
+    std::chrono::seconds getProofRegistrationTime(const ProofId &proofid) const;
 
     bool isOrphan(const ProofId &id) const;
     std::shared_ptr<Proof> getOrphan(const ProofId &id) const;
diff --git a/src/avalanche/peermanager.cpp b/src/avalanche/peermanager.cpp
--- a/src/avalanche/peermanager.cpp
+++ b/src/avalanche/peermanager.cpp
@@ -201,10 +201,12 @@
     return it == pview.end() ? nullptr : it->proof;
 }
 
-Peer::Timestamp PeerManager::getProofTime(const ProofId &proofid) const {
+std::chrono::seconds
+PeerManager::getProofRegistrationTime(const ProofId &proofid) const {
     auto &pview = peers.get<proof_index>();
     auto it = pview.find(proofid);
-    return it == pview.end() ? Peer::Timestamp::max() : it->time;
+    return it == pview.end() ? std::chrono::seconds::max()
+                             : it->registration_time;
 }
 
 PeerManager::PeerSet::iterator
diff --git a/src/avalanche/processor.h b/src/avalanche/processor.h
--- a/src/avalanche/processor.h
+++ b/src/avalanche/processor.h
@@ -290,7 +290,7 @@
     bool addProof(const std::shared_ptr<Proof> &proof);
     std::shared_ptr<Proof> getProof(const ProofId &proofid) const;
     std::shared_ptr<Proof> getLocalProof() const;
-    Peer::Timestamp getProofTime(const ProofId &proofid) const;
+    std::chrono::seconds getProofRegistrationTime(const ProofId &proofid) const;
     std::shared_ptr<Proof> getOrphan(const ProofId &proofid) const;
 
     /*
diff --git a/src/avalanche/processor.cpp b/src/avalanche/processor.cpp
--- a/src/avalanche/processor.cpp
+++ b/src/avalanche/processor.cpp
@@ -584,9 +584,10 @@
     return peerData ? peerData->proof : nullptr;
 }
 
-Peer::Timestamp Processor::getProofTime(const ProofId &proofid) const {
+std::chrono::seconds
+Processor::getProofRegistrationTime(const ProofId &proofid) const {
     LOCK(cs_peerManager);
-    return peerManager->getProofTime(proofid);
+    return peerManager->getProofRegistrationTime(proofid);
 }
 
 std::shared_ptr<Proof> Processor::getOrphan(const ProofId &proofid) const {
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
@@ -973,8 +973,7 @@
         proofs.push_back(GetProof());
     }
 
-    const Peer::Timestamp checkpoint =
-        Peer::Timestamp(std::chrono::seconds(GetTime()));
+    const auto checkpoint = GetTime<std::chrono::seconds>();
 
     for (int i = 0; i < numProofs; i++) {
         BOOST_CHECK(m_processor->addProof(proofs[i]));
@@ -988,17 +987,17 @@
             const ProofId &proofid = proof->getId();
             BOOST_CHECK_EQUAL(proofid, proofs[added]->getId());
 
-            const Peer::Timestamp proofTime =
-                m_processor->getProofTime(proofid);
-            BOOST_CHECK(proofTime != Peer::Timestamp::max());
+            const auto proofTime =
+                m_processor->getProofRegistrationTime(proofid);
+            BOOST_CHECK(proofTime != std::chrono::seconds::max());
             BOOST_CHECK(proofTime >= checkpoint);
         }
 
         for (int missing = i + 1; missing < numProofs; missing++) {
             const ProofId &proofid = proofs[missing]->getId();
             BOOST_CHECK(!m_processor->getProof(proofid));
-            BOOST_CHECK(m_processor->getProofTime(proofid) ==
-                        Peer::Timestamp::max());
+            BOOST_CHECK(m_processor->getProofRegistrationTime(proofid) ==
+                        std::chrono::seconds::max());
         }
     }
 
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -2068,11 +2068,10 @@
         return nullptr;
     }
 
-    auto proofTime = std::chrono::duration_cast<std::chrono::seconds>(
-        g_avalanche->getProofTime(proofid).time_since_epoch());
+    auto proofRegistrationTime = g_avalanche->getProofRegistrationTime(proofid);
 
     // If we know that proof for long enough, allow for requesting it
-    if (proofTime <= now - UNCONDITIONAL_RELAY_DELAY) {
+    if (proofRegistrationTime <= now - UNCONDITIONAL_RELAY_DELAY) {
         return proof;
     }