diff --git a/src/banman.h b/src/banman.h
--- a/src/banman.h
+++ b/src/banman.h
@@ -61,10 +61,10 @@
     //! clean unused entries (if bantime has expired)
     void SweepBanned();
 
-    banmap_t setBanned;
-    CCriticalSection cs_setBanned;
-    bool setBannedIsDirty;
-    CClientUIInterface *clientInterface = nullptr;
+    banmap_t m_banned;
+    CCriticalSection m_cs_banned;
+    bool m_is_dirty;
+    CClientUIInterface *m_client_interface = nullptr;
     CBanDB m_ban_db;
     int64_t m_default_ban_time;
 };
diff --git a/src/banman.cpp b/src/banman.cpp
--- a/src/banman.cpp
+++ b/src/banman.cpp
@@ -12,15 +12,15 @@
 
 BanMan::BanMan(fs::path ban_file, const CChainParams &chainParams,
                CClientUIInterface *client_interface, int64_t default_ban_time)
-    : clientInterface(client_interface),
+    : m_client_interface(client_interface),
       m_ban_db(std::move(ban_file), chainParams),
       m_default_ban_time(default_ban_time) {
-    if (clientInterface) {
-        clientInterface->InitMessage(_("Loading banlist..."));
+    if (m_client_interface) {
+        m_client_interface->InitMessage(_("Loading banlist..."));
     }
 
     int64_t nStart = GetTimeMillis();
-    setBannedIsDirty = false;
+    m_is_dirty = false;
     banmap_t banmap;
     if (m_ban_db.Read(banmap)) {
         // thread save setter
@@ -68,20 +68,20 @@
 
 void BanMan::ClearBanned() {
     {
-        LOCK(cs_setBanned);
-        setBanned.clear();
-        setBannedIsDirty = true;
+        LOCK(m_cs_banned);
+        m_banned.clear();
+        m_is_dirty = true;
     }
     // store banlist to disk
     DumpBanlist();
-    if (clientInterface) {
-        clientInterface->BannedListChanged();
+    if (m_client_interface) {
+        m_client_interface->BannedListChanged();
     }
 }
 
 bool BanMan::IsBanned(CNetAddr netAddr) {
-    LOCK(cs_setBanned);
-    for (const auto &it : setBanned) {
+    LOCK(m_cs_banned);
+    for (const auto &it : m_banned) {
         CSubNet subNet = it.first;
         CBanEntry banEntry = it.second;
 
@@ -93,9 +93,9 @@
 }
 
 bool BanMan::IsBanned(CSubNet subNet) {
-    LOCK(cs_setBanned);
-    banmap_t::iterator i = setBanned.find(subNet);
-    if (i != setBanned.end()) {
+    LOCK(m_cs_banned);
+    banmap_t::iterator i = m_banned.find(subNet);
+    if (i != m_banned.end()) {
         CBanEntry banEntry = (*i).second;
         if (GetTime() < banEntry.nBanUntil) {
             return true;
@@ -121,16 +121,16 @@
     banEntry.nBanUntil = (sinceUnixEpoch ? 0 : GetTime()) + bantimeoffset;
 
     {
-        LOCK(cs_setBanned);
-        if (setBanned[subNet].nBanUntil < banEntry.nBanUntil) {
-            setBanned[subNet] = banEntry;
-            setBannedIsDirty = true;
+        LOCK(m_cs_banned);
+        if (m_banned[subNet].nBanUntil < banEntry.nBanUntil) {
+            m_banned[subNet] = banEntry;
+            m_is_dirty = true;
         } else {
             return;
         }
     }
-    if (clientInterface) {
-        clientInterface->BannedListChanged();
+    if (m_client_interface) {
+        m_client_interface->BannedListChanged();
     }
 
     // store banlist to disk immediately if user requested ban
@@ -146,46 +146,47 @@
 
 bool BanMan::Unban(const CSubNet &subNet) {
     {
-        LOCK(cs_setBanned);
-        if (setBanned.erase(subNet) == 0) {
+        LOCK(m_cs_banned);
+        if (m_banned.erase(subNet) == 0) {
             return false;
         }
-        setBannedIsDirty = true;
+        m_is_dirty = true;
     }
-    if (clientInterface) {
-        clientInterface->BannedListChanged();
+    if (m_client_interface) {
+        m_client_interface->BannedListChanged();
     }
+
     // store banlist to disk immediately
     DumpBanlist();
     return true;
 }
 
 void BanMan::GetBanned(banmap_t &banMap) {
-    LOCK(cs_setBanned);
+    LOCK(m_cs_banned);
     // Sweep the banlist so expired bans are not returned
     SweepBanned();
     // create a thread safe copy
-    banMap = setBanned;
+    banMap = m_banned;
 }
 
 void BanMan::SetBanned(const banmap_t &banMap) {
-    LOCK(cs_setBanned);
-    setBanned = banMap;
-    setBannedIsDirty = true;
+    LOCK(m_cs_banned);
+    m_banned = banMap;
+    m_is_dirty = true;
 }
 
 void BanMan::SweepBanned() {
     int64_t now = GetTime();
     bool notifyUI = false;
     {
-        LOCK(cs_setBanned);
-        banmap_t::iterator it = setBanned.begin();
-        while (it != setBanned.end()) {
+        LOCK(m_cs_banned);
+        banmap_t::iterator it = m_banned.begin();
+        while (it != m_banned.end()) {
             CSubNet subNet = (*it).first;
             CBanEntry banEntry = (*it).second;
             if (now > banEntry.nBanUntil) {
-                setBanned.erase(it++);
-                setBannedIsDirty = true;
+                m_banned.erase(it++);
+                m_is_dirty = true;
                 notifyUI = true;
                 LogPrint(
                     BCLog::NET,
@@ -197,18 +198,18 @@
         }
     }
     // update UI
-    if (notifyUI && clientInterface) {
-        clientInterface->BannedListChanged();
+    if (notifyUI && m_client_interface) {
+        m_client_interface->BannedListChanged();
     }
 }
 
 bool BanMan::BannedSetIsDirty() {
-    LOCK(cs_setBanned);
-    return setBannedIsDirty;
+    LOCK(m_cs_banned);
+    return m_is_dirty;
 }
 
 void BanMan::SetBannedSetDirty(bool dirty) {
-    // reuse setBanned lock for the setBannedIsDirty flag
-    LOCK(cs_setBanned);
-    setBannedIsDirty = dirty;
+    // reuse m_banned lock for the m_is_dirty flag
+    LOCK(m_cs_banned);
+    m_is_dirty = dirty;
 }