diff --git a/src/avalanche/processor.h b/src/avalanche/processor.h
--- a/src/avalanche/processor.h
+++ b/src/avalanche/processor.h
@@ -54,6 +54,13 @@
 class Proof;
 struct VoteRecord;
 
+enum struct VoteStatus : uint8_t {
+    Invalid,
+    Rejected,
+    Accepted,
+    Finalized,
+};
+
 class BlockUpdate {
     union {
         CBlockIndex *pindex;
@@ -68,18 +75,11 @@
         "CBlockIndex alignement doesn't allow for Status to be stored.");
 
 public:
-    enum Status : uint8_t {
-        Invalid,
-        Rejected,
-        Accepted,
-        Finalized,
-    };
-
-    BlockUpdate(CBlockIndex *pindexIn, Status statusIn) : pindex(pindexIn) {
-        raw |= statusIn;
+    BlockUpdate(CBlockIndex *pindexIn, VoteStatus statusIn) : pindex(pindexIn) {
+        raw |= static_cast<uint8_t>(statusIn);
     }
 
-    Status getStatus() const { return Status(raw & MASK); }
+    VoteStatus getStatus() const { return VoteStatus(raw & MASK); }
 
     CBlockIndex *getBlockIndex() {
         return reinterpret_cast<CBlockIndex *>(raw & ~MASK);
diff --git a/src/avalanche/processor.cpp b/src/avalanche/processor.cpp
--- a/src/avalanche/processor.cpp
+++ b/src/avalanche/processor.cpp
@@ -416,17 +416,16 @@
             if (!vr.hasFinalized()) {
                 // This item has note been finalized, so we have nothing more to
                 // do.
-                updates.emplace_back(
-                    pindex, vr.isAccepted() ? BlockUpdate::Status::Accepted
-                                            : BlockUpdate::Status::Rejected);
+                updates.emplace_back(pindex, vr.isAccepted()
+                                                 ? VoteStatus::Accepted
+                                                 : VoteStatus::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()
-                                             ? BlockUpdate::Status::Finalized
-                                             : BlockUpdate::Status::Invalid);
+            updates.emplace_back(pindex, vr.isAccepted() ? VoteStatus::Finalized
+                                                         : VoteStatus::Invalid);
             w->erase(it);
         }
     }
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
@@ -292,17 +292,19 @@
     CBlockIndex index;
     CBlockIndex *pindex = &index;
 
-    std::set<BlockUpdate::Status> status{
-        BlockUpdate::Status::Invalid,
-        BlockUpdate::Status::Rejected,
-        BlockUpdate::Status::Accepted,
-        BlockUpdate::Status::Finalized,
+    std::set<VoteStatus> status{
+        VoteStatus::Invalid,
+        VoteStatus::Rejected,
+        VoteStatus::Accepted,
+        VoteStatus::Finalized,
     };
 
     for (auto s : status) {
         BlockUpdate abu(pindex, s);
+        // The use of BOOST_CHECK instead of BOOST_CHECK_EQUAL prevents from
+        // having to define operator<<() for each argument type.
         BOOST_CHECK(abu.getBlockIndex() == pindex);
-        BOOST_CHECK_EQUAL(abu.getStatus(), s);
+        BOOST_CHECK(abu.getStatus() == s);
     }
 }
 
@@ -409,7 +411,7 @@
     registerNewVote(next(resp));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindex);
-    BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Finalized);
+    BOOST_CHECK(updates[0].getStatus() == VoteStatus::Finalized);
     updates = {};
 
     // Once the decision is finalized, there is no poll for it.
@@ -435,7 +437,7 @@
     BOOST_CHECK(!m_processor->isAccepted(pindex));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindex);
-    BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Rejected);
+    BOOST_CHECK(updates[0].getStatus() == VoteStatus::Rejected);
     updates = {};
 
     // Now it is rejected, but we can vote for it numerous times.
@@ -456,7 +458,7 @@
     BOOST_CHECK(!m_processor->isAccepted(pindex));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindex);
-    BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Invalid);
+    BOOST_CHECK(updates[0].getStatus() == VoteStatus::Invalid);
     updates = {};
 
     // Once the decision is finalized, there is no poll for it.
@@ -549,7 +551,7 @@
     BOOST_CHECK(registerVotes(firstNodeid, next(resp), updates));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindexA);
-    BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Finalized);
+    BOOST_CHECK(updates[0].getStatus() == VoteStatus::Finalized);
     updates = {};
 
     // We do not vote on A anymore.
@@ -562,7 +564,7 @@
     BOOST_CHECK(registerVotes(secondNodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindexB);
-    BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Finalized);
+    BOOST_CHECK(updates[0].getStatus() == VoteStatus::Finalized);
     updates = {};
 
     // There is nothing left to vote on.
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -4394,8 +4394,8 @@
             for (avalanche::BlockUpdate &u : updates) {
                 CBlockIndex *pindex = u.getBlockIndex();
                 switch (u.getStatus()) {
-                    case avalanche::BlockUpdate::Status::Invalid:
-                    case avalanche::BlockUpdate::Status::Rejected: {
+                    case avalanche::VoteStatus::Invalid:
+                    case avalanche::VoteStatus::Rejected: {
                         LogPrintf("Avalanche rejected %s, parking\n",
                                   pindex->GetBlockHash().GetHex());
                         BlockValidationState state;
@@ -4406,8 +4406,8 @@
                             return;
                         }
                     } break;
-                    case avalanche::BlockUpdate::Status::Accepted:
-                    case avalanche::BlockUpdate::Status::Finalized: {
+                    case avalanche::VoteStatus::Accepted:
+                    case avalanche::VoteStatus::Finalized: {
                         LogPrintf("Avalanche accepted %s\n",
                                   pindex->GetBlockHash().GetHex());
                         LOCK(cs_main);