diff --git a/src/avalanche.cpp b/src/avalanche.cpp
index 46f971bb2d..bff755652e 100644
--- a/src/avalanche.cpp
+++ b/src/avalanche.cpp
@@ -1,417 +1,417 @@
 // Copyright (c) 2018 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include "avalanche.h"
 
 #include "chain.h"
 #include "config/bitcoin-config.h"
 #include "netmessagemaker.h"
 #include "scheduler.h"
 #include "validation.h"
 
 #include <boost/range/adaptor/reversed.hpp>
 
 #include <tuple>
 
 static uint32_t countBits(uint32_t v) {
 #if HAVE_DECL___BUILTIN_POPCOUNT
     return __builtin_popcount(v);
 #else
     /**
      * This computes the number of bits set in each group of 8bits then uses a
      * multiplication to sum all of them in the 8 most significant bits and
      * return these.
      * More detailed explaination can be found at
      * https://www.playingwithpointers.com/blog/swar.html
      */
     v = v - ((v >> 1) & 0x55555555);
     v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
     return (((v + (v >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
 #endif
 }
 
 bool VoteRecord::registerVote(uint32_t error) {
     /**
      * The result of the vote is determined from the error code. If the error
      * code is 0, there is no error and therefore the vote is yes. If there is
      * an error, we check the most signficant bit to decide if the vote is a no
      * (for instance, the block is invalid) or is the vote inconclusive (for
      * instance, the queried node do not have the block yet).
      */
     votes = (votes << 1) | (error == 0);
     consider = (consider << 1) | (int32_t(error) >= 0);
 
     /**
      * We compute the number of yes and/or no votes as follow:
      *
      * votes:     1010
      * consider:  1100
      *
      * yes votes: 1000 using votes & consider
      * no votes:  0100 using ~votes & consider
      */
     bool yes = countBits(votes & consider & 0xff) > 6;
     if (!yes) {
         bool no = countBits(~votes & consider & 0xff) > 6;
         if (!no) {
             // The round is inconclusive.
             return false;
         }
     }
 
     // If the round is in agreement with previous rounds, increase confidence.
     if (isAccepted() == yes) {
         confidence += 2;
         return getConfidence() == AVALANCHE_FINALIZATION_SCORE;
     }
 
     // The round changed our state. We reset the confidence.
     confidence = yes;
     return true;
 }
 
 static bool IsWorthPolling(const CBlockIndex *pindex) {
     AssertLockHeld(cs_main);
 
     if (pindex->nStatus.isInvalid()) {
         // No point polling invalid blocks.
         return false;
     }
 
     if (IsBlockFinalized(pindex)) {
         // There is no point polling finalized block.
         return false;
     }
 
     return true;
 }
 
 bool AvalancheProcessor::addBlockToReconcile(const CBlockIndex *pindex) {
     bool isAccepted;
 
     {
         LOCK(cs_main);
         if (!IsWorthPolling(pindex)) {
             // There is no point polling this block.
             return false;
         }
 
         isAccepted = chainActive.Contains(pindex);
     }
 
     return vote_records.getWriteView()
         ->insert(std::make_pair(pindex, VoteRecord(isAccepted)))
         .second;
 }
 
 static const VoteRecord *
 GetRecord(const RWCollection<BlockVoteMap> &vote_records,
           const CBlockIndex *pindex) {
     auto r = vote_records.getReadView();
     auto it = r->find(pindex);
     if (it == r.end()) {
         return nullptr;
     }
 
     return &it->second;
 }
 
 bool AvalancheProcessor::isAccepted(const CBlockIndex *pindex) const {
     if (auto vr = GetRecord(vote_records, pindex)) {
         return vr->isAccepted();
     }
 
     return false;
 }
 
 int AvalancheProcessor::getConfidence(const CBlockIndex *pindex) const {
     if (auto vr = GetRecord(vote_records, pindex)) {
         return vr->getConfidence();
     }
 
     return -1;
 }
 
 bool AvalancheProcessor::registerVotes(
     NodeId nodeid, const AvalancheResponse &response,
     std::vector<AvalancheBlockUpdate> &updates) {
     {
         // Save the time at which we can query again.
         auto w = peerSet.getWriteView();
         auto it = w->find(nodeid);
         if (it != w->end()) {
             w->modify(it, [&response](Peer &p) {
                 // FIXME: This will override the time even when we received an
                 // old stale message. This should check that the message is
                 // indeed the most up to date one before updating the time.
                 p.nextRequestTime =
                     std::chrono::steady_clock::now() +
                     std::chrono::milliseconds(response.getCooldown());
             });
         }
     }
 
     std::vector<CInv> invs;
 
     {
         // Check that the query exists.
         auto w = queries.getWriteView();
         auto it = w->find(std::make_tuple(nodeid, response.getRound()));
         if (it == w.end()) {
             // NB: The request may be old, so we don't increase banscore.
             return false;
         }
 
         invs = std::move(it->invs);
         w->erase(it);
     }
 
     // Verify that the request and the vote are consistent.
     const std::vector<AvalancheVote> &votes = response.GetVotes();
     size_t size = invs.size();
     if (votes.size() != size) {
         // TODO: increase banscore for inconsistent response.
         // NB: This isn't timeout but actually node misbehaving.
         return false;
     }
 
     for (size_t i = 0; i < size; i++) {
         if (invs[i].hash != votes[i].GetHash()) {
             // TODO: increase banscore for inconsistent response.
             // NB: This isn't timeout but actually node misbehaving.
             return false;
         }
     }
 
     std::map<CBlockIndex *, AvalancheVote> responseIndex;
 
     {
         LOCK(cs_main);
         for (auto &v : votes) {
             BlockMap::iterator mi = mapBlockIndex.find(v.GetHash());
             if (mi == mapBlockIndex.end()) {
                 // This should not happen, but just in case...
                 continue;
             }
 
             CBlockIndex *pindex = mi->second;
             if (!IsWorthPolling(pindex)) {
                 // There is no point polling this block.
                 continue;
             }
 
             responseIndex.insert(std::make_pair(pindex, v));
         }
     }
 
     {
         // Register votes.
         auto w = vote_records.getWriteView();
         for (auto &p : responseIndex) {
             CBlockIndex *pindex = p.first;
             const AvalancheVote &v = p.second;
 
             auto it = w->find(pindex);
             if (it == w.end()) {
                 // We are not voting on that item anymore.
                 continue;
             }
 
             auto &vr = it->second;
             if (!vr.registerVote(v.GetError())) {
                 // This vote did not provide any extra information, move on.
                 continue;
             }
 
             if (!vr.hasFinalized()) {
                 // This item has note been finalized, so we have nothing more to
                 // do.
                 updates.emplace_back(
                     pindex,
                     vr.isAccepted() ? AvalancheBlockUpdate::Status::Accepted
                                     : AvalancheBlockUpdate::Status::Rejected);
                 continue;
             }
 
             // We just finalized a vote. If it is valid, then let the caller
             // know. Either way, remove the item from the map.
             updates.emplace_back(pindex,
                                  vr.isAccepted()
                                      ? AvalancheBlockUpdate::Status::Finalized
                                      : AvalancheBlockUpdate::Status::Invalid);
             w->erase(it);
         }
     }
 
     return true;
 }
 
-bool AvalancheProcessor::addPeer(NodeId nodeid, uint32_t score) {
+bool AvalancheProcessor::addPeer(NodeId nodeid, int64_t score) {
     return peerSet.getWriteView()
         ->insert({nodeid, score, std::chrono::steady_clock::now()})
         .second;
 }
 
 namespace {
 /**
  * Run the avalanche event loop every 10ms.
  */
 static int64_t AVALANCHE_TIME_STEP_MILLISECONDS = 10;
 /**
  * Maximum item that can be polled at once.
  */
 static size_t AVALANCHE_MAX_ELEMENT_POLL = 4096;
 }
 
 bool AvalancheProcessor::startEventLoop(CScheduler &scheduler) {
     LOCK(cs_running);
     if (running) {
         // Do not start the event loop twice.
         return false;
     }
 
     running = true;
 
     // Start the event loop.
     scheduler.scheduleEvery(
         [this]() -> bool {
             runEventLoop();
             if (!stopRequest) {
                 return true;
             }
 
             LOCK(cs_running);
             running = false;
 
             cond_running.notify_all();
 
             // A stop request was made.
             return false;
         },
         AVALANCHE_TIME_STEP_MILLISECONDS);
 
     return true;
 }
 
 bool AvalancheProcessor::stopEventLoop() {
     WAIT_LOCK(cs_running, lock);
     if (!running) {
         return false;
     }
 
     // Request avalanche to stop.
     stopRequest = true;
 
     // Wait for avalanche to stop.
     cond_running.wait(lock, [this] { return !running; });
 
     stopRequest = false;
     return true;
 }
 
 std::vector<CInv> AvalancheProcessor::getInvsForNextPoll() const {
     std::vector<CInv> invs;
 
     auto r = vote_records.getReadView();
     for (const std::pair<const CBlockIndex *, VoteRecord> &p :
          boost::adaptors::reverse(r)) {
         const CBlockIndex *pindex = p.first;
         if (!IsWorthPolling(pindex)) {
             // Obviously do not poll if the block is not worth polling.
             continue;
         }
 
         // We don't have a decision, we need more votes.
         invs.emplace_back(MSG_BLOCK, p.first->GetBlockHash());
         if (invs.size() >= AVALANCHE_MAX_ELEMENT_POLL) {
             // Make sure we do not produce more invs than specified by the
             // protocol.
             return invs;
         }
     }
 
     return invs;
 }
 
 NodeId AvalancheProcessor::getSuitableNodeToQuery() {
     auto r = peerSet.getReadView();
     auto it = r->get<next_request_time>().begin();
     if (it == r->get<next_request_time>().end()) {
         return NO_NODE;
     }
 
     if (it->nextRequestTime <= std::chrono::steady_clock::now()) {
         return it->nodeid;
     }
 
     return NO_NODE;
 }
 
 void AvalancheProcessor::runEventLoop() {
     auto now = std::chrono::steady_clock::now();
 
     {
         // Clear expired requests.
         auto w = queries.getWriteView();
         auto it = w->get<query_timeout>().begin();
         while (it != w->get<query_timeout>().end() && it->timeout < now) {
             w->get<query_timeout>().erase(it++);
         }
     }
 
     std::vector<CInv> invs = getInvsForNextPoll();
     if (invs.empty()) {
         // If there are no invs to poll, we are done.
         return;
     }
 
     while (true) {
         NodeId nodeid = getSuitableNodeToQuery();
         if (nodeid == NO_NODE) {
             return;
         }
 
         /**
          * If we lost contact to that node, then we remove it from nodeids, but
          * never add the request to queries, which ensures bad nodes get cleaned
          * up over time.
          */
         bool hasSent = connman->ForNode(nodeid, [this, &invs](CNode *pnode) {
             uint64_t current_round = round++;
 
             {
                 // Compute the time at which this requests times out.
                 auto timeout =
                     std::chrono::steady_clock::now() + queryTimeoutDuration;
                 // Register the query.
                 queries.getWriteView()->insert(
                     {pnode->GetId(), current_round, timeout, invs});
                 // Set the timeout.
                 auto w = peerSet.getWriteView();
                 auto it = w->find(pnode->GetId());
                 if (it != w->end()) {
                     w->modify(it, [&timeout](Peer &p) {
                         p.nextRequestTime = timeout;
                     });
                 }
             }
 
             // Send the query to the node.
             connman->PushMessage(
                 pnode,
                 CNetMsgMaker(pnode->GetSendVersion())
                     .Make(NetMsgType::AVAPOLL,
                           AvalanchePoll(current_round, std::move(invs))));
             return true;
         });
 
         // Success !
         if (hasSent) {
             return;
         }
 
         // This node is obsolete, delete it.
         peerSet.getWriteView()->erase(nodeid);
     }
 }
diff --git a/src/avalanche.h b/src/avalanche.h
index 98e4ec86d1..4a1737910c 100644
--- a/src/avalanche.h
+++ b/src/avalanche.h
@@ -1,291 +1,291 @@
 // Copyright (c) 2018 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_AVALANCHE_H
 #define BITCOIN_AVALANCHE_H
 
 #include "blockindexworkcomparator.h"
 #include "net.h"
 #include "protocol.h" // for CInv
 #include "rwcollection.h"
 #include "serialize.h"
 #include "uint256.h"
 
 #include <boost/multi_index/composite_key.hpp>
 #include <boost/multi_index/hashed_index.hpp>
 #include <boost/multi_index/member.hpp>
 #include <boost/multi_index/ordered_index.hpp>
 #include <boost/multi_index_container.hpp>
 
 #include <atomic>
 #include <chrono>
 #include <condition_variable>
 #include <cstdint>
 #include <vector>
 
 class Config;
 class CBlockIndex;
 class CScheduler;
 
 namespace {
 /**
  * Finalization score.
  */
 static int AVALANCHE_FINALIZATION_SCORE = 128;
 /**
  * How long before we consider that a query timed out.
  */
 static int AVALANCHE_DEFAULT_QUERY_TIMEOUT_DURATION_MILLISECONDS = 10000;
 /**
  * Special NodeId that represent no node.
  */
 static const NodeId NO_NODE = -1;
 }
 
 /**
  * Vote history.
  */
 struct VoteRecord {
 private:
     // Historical record of votes.
     uint8_t votes;
     // Each bit indicate if the vote is to be considered.
     uint8_t consider;
 
     // confidence's LSB bit is the result. Higher bits are actual confidence
     // score.
     uint16_t confidence;
 
 public:
     VoteRecord(bool accepted) : votes(0), consider(0), confidence(accepted) {}
 
     bool isAccepted() const { return confidence & 0x01; }
 
     uint16_t getConfidence() const { return confidence >> 1; }
     bool hasFinalized() const {
         return getConfidence() >= AVALANCHE_FINALIZATION_SCORE;
     }
 
     /**
      * Register a new vote for an item and update confidence accordingly.
      * Returns true if the acceptance or finalization state changed.
      */
     bool registerVote(uint32_t error);
 };
 
 class AvalancheVote {
     uint32_t error;
     uint256 hash;
 
 public:
     AvalancheVote() : error(-1), hash() {}
     AvalancheVote(uint32_t errorIn, uint256 hashIn)
         : error(errorIn), hash(hashIn) {}
 
     const uint256 &GetHash() const { return hash; }
     uint32_t GetError() const { return error; }
 
     // serialization support
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(error);
         READWRITE(hash);
     }
 };
 
 class AvalancheResponse {
     uint64_t round;
     uint32_t cooldown;
     std::vector<AvalancheVote> votes;
 
 public:
     AvalancheResponse(uint64_t roundIn, uint32_t cooldownIn,
                       std::vector<AvalancheVote> votesIn)
         : round(roundIn), cooldown(cooldownIn), votes(votesIn) {}
 
     uint64_t getRound() const { return round; }
     uint32_t getCooldown() const { return cooldown; }
     const std::vector<AvalancheVote> &GetVotes() const { return votes; }
 
     // serialization support
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(round);
         READWRITE(cooldown);
         READWRITE(votes);
     }
 };
 
 class AvalanchePoll {
     uint64_t round;
     std::vector<CInv> invs;
 
 public:
-    AvalanchePoll(uint32_t roundIn, std::vector<CInv> invsIn)
+    AvalanchePoll(uint64_t roundIn, std::vector<CInv> invsIn)
         : round(roundIn), invs(invsIn) {}
 
     const std::vector<CInv> &GetInvs() const { return invs; }
 
     // serialization support
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(round);
         READWRITE(invs);
     }
 };
 
 class AvalancheBlockUpdate {
     union {
         CBlockIndex *pindex;
         size_t raw;
     };
 
 public:
     enum Status : uint8_t {
         Invalid,
         Rejected,
         Accepted,
         Finalized,
     };
 
     AvalancheBlockUpdate(CBlockIndex *pindexIn, Status statusIn)
         : pindex(pindexIn) {
         raw |= statusIn;
     }
 
     Status getStatus() const { return Status(raw & 0x03); }
 
     CBlockIndex *getBlockIndex() {
         return reinterpret_cast<CBlockIndex *>(raw & -size_t(0x04));
     }
 
     const CBlockIndex *getBlockIndex() const {
         return const_cast<AvalancheBlockUpdate *>(this)->getBlockIndex();
     }
 };
 
 typedef std::map<const CBlockIndex *, VoteRecord, CBlockIndexWorkComparator>
     BlockVoteMap;
 
 struct next_request_time {};
 struct query_timeout {};
 
 class AvalancheProcessor {
 private:
     CConnman *connman;
     std::chrono::milliseconds queryTimeoutDuration;
 
     /**
      * Blocks to run avalanche on.
      */
     RWCollection<BlockVoteMap> vote_records;
 
     /**
      * Keep track of peers and queries sent.
      */
     std::atomic<uint64_t> round;
 
     typedef std::chrono::time_point<std::chrono::steady_clock> TimePoint;
 
     struct Peer {
         NodeId nodeid;
         int64_t score;
 
         TimePoint nextRequestTime;
     };
 
     typedef boost::multi_index_container<
         Peer, boost::multi_index::indexed_by<
                   // index by nodeid
                   boost::multi_index::hashed_unique<
                       boost::multi_index::member<Peer, NodeId, &Peer::nodeid>>,
                   // sorted by nextRequestTime
                   boost::multi_index::ordered_non_unique<
                       boost::multi_index::tag<next_request_time>,
                       boost::multi_index::member<Peer, TimePoint,
                                                  &Peer::nextRequestTime>>>>
         PeerSet;
 
     RWCollection<PeerSet> peerSet;
 
     struct Query {
         NodeId nodeid;
         uint64_t round;
         TimePoint timeout;
 
         /**
          * We declare this as mutable so it can be modified in the multi_index.
          * This is ok because we do not use this field to index in anyway.
          *
          * /!\ Do not use any mutable field as index.
          */
         mutable std::vector<CInv> invs;
     };
 
     typedef boost::multi_index_container<
         Query,
         boost::multi_index::indexed_by<
             // index by nodeid/round
             boost::multi_index::ordered_unique<
                 boost::multi_index::composite_key<
                     Query,
                     boost::multi_index::member<Query, NodeId, &Query::nodeid>,
                     boost::multi_index::member<Query, uint64_t,
                                                &Query::round>>>,
             // sorted by timeout
             boost::multi_index::ordered_non_unique<
                 boost::multi_index::tag<query_timeout>,
                 boost::multi_index::member<Query, TimePoint, &Query::timeout>>>>
         QuerySet;
 
     RWCollection<QuerySet> queries;
 
     /**
      * Start stop machinery.
      */
     std::atomic<bool> stopRequest;
     bool running GUARDED_BY(cs_running);
 
     CWaitableCriticalSection cs_running;
     std::condition_variable cond_running;
 
 public:
     AvalancheProcessor(CConnman *connmanIn)
         : connman(connmanIn),
           queryTimeoutDuration(
               AVALANCHE_DEFAULT_QUERY_TIMEOUT_DURATION_MILLISECONDS),
           round(0), stopRequest(false), running(false) {}
     ~AvalancheProcessor() { stopEventLoop(); }
 
     void setQueryTimeoutDuration(std::chrono::milliseconds d) {
         queryTimeoutDuration = d;
     }
 
     bool addBlockToReconcile(const CBlockIndex *pindex);
     bool isAccepted(const CBlockIndex *pindex) const;
     int getConfidence(const CBlockIndex *pindex) const;
 
     bool registerVotes(NodeId nodeid, const AvalancheResponse &response,
                        std::vector<AvalancheBlockUpdate> &updates);
 
-    bool addPeer(NodeId nodeid, uint32_t score);
+    bool addPeer(NodeId nodeid, int64_t score);
 
     bool startEventLoop(CScheduler &scheduler);
     bool stopEventLoop();
 
 private:
     void runEventLoop();
     std::vector<CInv> getInvsForNextPoll() const;
     NodeId getSuitableNodeToQuery();
 
     friend struct AvalancheTest;
 };
 
 #endif // BITCOIN_AVALANCHE_H