diff --git a/src/governance/classes.h b/src/governance/classes.h
index f106f1d8b8ee..6f300f9d8cba 100644
--- a/src/governance/classes.h
+++ b/src/governance/classes.h
@@ -5,6 +5,7 @@
 #define BITCOIN_GOVERNANCE_CLASSES_H
 
 #include <amount.h>
+#include <governance/governance.h>
 #include <governance/object.h>
 #include <script/script.h>
 #include <script/standard.h>
@@ -37,9 +38,9 @@ class CGovernanceTriggerManager
 private:
     std::map<uint256, CSuperblock_sptr> mapTrigger;
 
-    std::vector<CSuperblock_sptr> GetActiveTriggers();
-    bool AddNewTrigger(uint256 nHash);
-    void CleanAndRemove();
+    std::vector<CSuperblock_sptr> GetActiveTriggers() EXCLUSIVE_LOCKS_REQUIRED(governance.cs);
+    bool AddNewTrigger(uint256 nHash) EXCLUSIVE_LOCKS_REQUIRED(governance.cs);
+    void CleanAndRemove() EXCLUSIVE_LOCKS_REQUIRED(governance.cs);
 
 public:
     CGovernanceTriggerManager() :
@@ -55,7 +56,7 @@ class CGovernanceTriggerManager
 class CSuperblockManager
 {
 private:
-    static bool GetBestSuperblock(CSuperblock_sptr& pSuperblockRet, int nBlockHeight);
+    static bool GetBestSuperblock(CSuperblock_sptr& pSuperblockRet, int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(governance.cs);
 
 public:
     static bool IsSuperblockTriggered(int nBlockHeight);
@@ -135,7 +136,7 @@ class CSuperblock : public CGovernanceObject
     // TELL THE ENGINE WE EXECUTED THIS EVENT
     void SetExecuted() { nStatus = SEEN_OBJECT_EXECUTED; }
 
-    CGovernanceObject* GetGovernanceObject();
+    CGovernanceObject* GetGovernanceObject() EXCLUSIVE_LOCKS_REQUIRED(governance.cs);
 
     int GetBlockHeight() const
     {
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index b3996b20aba4..abc3e7f66b3a 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -28,22 +28,6 @@ const std::string CGovernanceManager::SERIALIZATION_VERSION_STRING = "CGovernanc
 const int CGovernanceManager::MAX_TIME_FUTURE_DEVIATION = 60 * 60;
 const int CGovernanceManager::RELIABLE_PROPAGATION_TIME = 60;
 
-CGovernanceManager::CGovernanceManager() :
-    nTimeLastDiff(0),
-    nCachedBlockHeight(0),
-    mapObjects(),
-    mapErasedGovernanceObjects(),
-    cmapVoteToObject(MAX_CACHE_SIZE),
-    cmapInvalidVotes(MAX_CACHE_SIZE),
-    cmmapOrphanVotes(MAX_CACHE_SIZE),
-    mapLastMasternodeObject(),
-    setRequestedObjects(),
-    fRateChecksEnabled(true),
-    lastMNListForVotingKeys(std::make_shared<CDeterministicMNList>()),
-    cs()
-{
-}
-
 // Accessors for thread-safe access to maps
 bool CGovernanceManager::HaveObjectForHash(const uint256& nHash) const
 {
@@ -180,7 +164,7 @@ void CGovernanceManager::ProcessMessage(CNode* pfrom, const std::string& strComm
         // CHECK OBJECT AGAINST LOCAL BLOCKCHAIN
 
         bool fMissingConfirmations = false;
-        bool fIsValid = govobj.IsValidLocally(strError, fMissingConfirmations, true);
+        bool fIsValid = WITH_LOCK(govobj.cs, return govobj.IsValidLocally(strError, fMissingConfirmations, true));
 
         if (fRateCheckBypassed && fIsValid && !MasternodeRateCheck(govobj, true)) {
             LogPrint(BCLog::GOBJECT, "MNGOVERNANCEOBJECT -- masternode rate check failed (after signature verification) - %s - (current block height %d)\n", strHash, nCachedBlockHeight);
@@ -260,6 +244,7 @@ void CGovernanceManager::CheckOrphanVotes(CGovernanceObject& govobj, CConnman& c
 {
     uint256 nHash = govobj.GetHash();
     std::vector<vote_time_pair_t> vecVotePairs;
+    LOCK(cs);
     cmmapOrphanVotes.GetAll(nHash, vecVotePairs);
 
     ScopedLockBool guard(cs, fRateChecksEnabled, false);
@@ -295,7 +280,7 @@ void CGovernanceManager::AddGovernanceObject(CGovernanceObject& govobj, CConnman
 
     // MAKE SURE THIS OBJECT IS OK
 
-    if (!govobj.IsValidLocally(strError, true)) {
+    if (!WITH_LOCK(govobj.cs, return govobj.IsValidLocally(strError, true))) {
         LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- invalid governance object - %s - (nCachedBlockHeight %d) \n", strError, nCachedBlockHeight);
         return;
     }
@@ -316,7 +301,7 @@ void CGovernanceManager::AddGovernanceObject(CGovernanceObject& govobj, CConnman
     LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- Before trigger block, GetDataAsPlainString = %s, nObjectType = %d\n",
                 govobj.GetDataAsPlainString(), govobj.GetObjectType());
 
-    if (govobj.GetObjectType() == GOVERNANCE_OBJECT_TRIGGER && !triggerman.AddNewTrigger(nHash)) {
+    if (govobj.GetObjectType() == GOVERNANCE_OBJECT_TRIGGER && !WITH_LOCK(governance.cs, return triggerman.AddNewTrigger(nHash))) {
         LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- undo adding invalid trigger object: hash = %s\n", nHash.ToString());
         objpair.first->second.PrepareDeletion(GetAdjustedTime());
         return;
@@ -362,8 +347,10 @@ void CGovernanceManager::UpdateCachesAndClean()
     ScopedLockBool guard(cs, fRateChecksEnabled, false);
 
     // Clean up any expired or invalid triggers
-    triggerman.CleanAndRemove();
-
+    {
+        LOCK(governance.cs);
+        triggerman.CleanAndRemove();
+    }
     auto it = mapObjects.begin();
     int64_t nNow = GetAdjustedTime();
 
@@ -703,6 +690,7 @@ void CGovernanceManager::MasternodeRateUpdate(const CGovernanceObject& govobj)
     if (govobj.GetObjectType() != GOVERNANCE_OBJECT_TRIGGER) return;
 
     const COutPoint& masternodeOutpoint = govobj.GetMasternodeOutpoint();
+    LOCK(cs);
     auto it = mapLastMasternodeObject.find(masternodeOutpoint);
 
     if (it == mapLastMasternodeObject.end()) {
@@ -859,6 +847,7 @@ void CGovernanceManager::CheckPostponedObjects(CConnman& connman)
 
         std::string strError;
         bool fMissingConfirmations;
+        LOCK(govobj.cs);
         if (govobj.IsCollateralValid(strError, fMissingConfirmations)) {
             if (govobj.IsValidLocally(strError, false)) {
                 AddGovernanceObject(govobj, connman);
@@ -1102,7 +1091,7 @@ void CGovernanceManager::AddCachedTriggers()
             continue;
         }
 
-        if (!triggerman.AddNewTrigger(govobj.GetHash())) {
+        if (!WITH_LOCK(governance.cs, return triggerman.AddNewTrigger(govobj.GetHash()))) {
             govobj.PrepareDeletion(GetAdjustedTime());
         }
     }
@@ -1191,7 +1180,7 @@ void CGovernanceManager::UpdatedBlockTip(const CBlockIndex* pindex, CConnman& co
     }
 
     nCachedBlockHeight = pindex->nHeight;
-    LogPrint(BCLog::GOBJECT, "CGovernanceManager::UpdatedBlockTip -- nCachedBlockHeight: %d\n", nCachedBlockHeight);
+    LogPrint(BCLog::GOBJECT, "CGovernanceManager::UpdatedBlockTip -- nCachedBlockHeight: %d\n", pindex->nHeight);
 
     if (deterministicMNManager->IsDIP3Enforced(pindex->nHeight)) {
         RemoveInvalidVotes();
diff --git a/src/governance/governance.h b/src/governance/governance.h
index 8d30df7cc686..e90f9b141668 100644
--- a/src/governance/governance.h
+++ b/src/governance/governance.h
@@ -7,6 +7,7 @@
 
 #include <cachemap.h>
 #include <cachemultimap.h>
+#include <evo/deterministicmns.h>
 #include <governance/object.h>
 
 class CBloomFilter;
@@ -18,12 +19,14 @@ class CGovernanceTriggerManager;
 class CGovernanceObject;
 class CGovernanceVote;
 
+using CDeterministicMNListPtr = std::shared_ptr<CDeterministicMNList>;
+
 extern CGovernanceManager governance;
 
 static const int RATE_BUFFER_SIZE = 5;
 
 class CDeterministicMNList;
-using CDeterministicMNListPtr = std::shared_ptr<CDeterministicMNList>;
+typedef std::shared_ptr<CDeterministicMNList> CDeterministicMNListPtr;
 
 class CRateCheckBuffer
 {
@@ -161,38 +164,38 @@ class CGovernanceManager
     static const int MAX_TIME_FUTURE_DEVIATION;
     static const int RELIABLE_PROPAGATION_TIME;
 
-    int64_t nTimeLastDiff;
+    std::atomic<int64_t> nTimeLastDiff;
 
     // keep track of current block height
-    int nCachedBlockHeight;
+    std::atomic<int> nCachedBlockHeight;
 
     // keep track of the scanning errors
-    std::map<uint256, CGovernanceObject> mapObjects;
+    std::map<uint256, CGovernanceObject> mapObjects GUARDED_BY(cs);
 
     // mapErasedGovernanceObjects contains key-value pairs, where
     //   key   - governance object's hash
     //   value - expiration time for deleted objects
-    std::map<uint256, int64_t> mapErasedGovernanceObjects;
+    std::map<uint256, int64_t> mapErasedGovernanceObjects GUARDED_BY(cs);
 
-    std::map<uint256, CGovernanceObject> mapPostponedObjects;
-    hash_s_t setAdditionalRelayObjects;
+    std::map<uint256, CGovernanceObject> mapPostponedObjects GUARDED_BY(cs);
+    hash_s_t setAdditionalRelayObjects GUARDED_BY(cs);
 
-    object_ref_cm_t cmapVoteToObject;
+    object_ref_cm_t cmapVoteToObject GUARDED_BY(cs) {MAX_CACHE_SIZE};
 
-    CacheMap<uint256, CGovernanceVote> cmapInvalidVotes;
+    CacheMap<uint256, CGovernanceVote> cmapInvalidVotes GUARDED_BY(cs) {MAX_CACHE_SIZE};
 
-    vote_cmm_t cmmapOrphanVotes;
+    vote_cmm_t cmmapOrphanVotes GUARDED_BY(cs) {MAX_CACHE_SIZE};
 
-    txout_m_t mapLastMasternodeObject;
+    txout_m_t mapLastMasternodeObject GUARDED_BY(cs);
 
-    hash_s_t setRequestedObjects;
+    hash_s_t setRequestedObjects GUARDED_BY(cs);
 
-    hash_s_t setRequestedVotes;
+    hash_s_t setRequestedVotes GUARDED_BY(cs);
 
-    bool fRateChecksEnabled;
+    bool fRateChecksEnabled{true};
 
     // used to check for changed voting keys
-    CDeterministicMNListPtr lastMNListForVotingKeys;
+    CDeterministicMNListPtr lastMNListForVotingKeys GUARDED_BY(cs) {std::make_shared<CDeterministicMNList>()};
 
     class ScopedLockBool
     {
@@ -218,7 +221,7 @@ class CGovernanceManager
     // critical section to protect the inner data structures
     mutable CCriticalSection cs;
 
-    CGovernanceManager();
+    CGovernanceManager() = default;
 
     virtual ~CGovernanceManager() = default;
 
@@ -353,6 +356,7 @@ class CGovernanceManager
 
     void AddInvalidVote(const CGovernanceVote& vote)
     {
+        LOCK(cs);
         cmapInvalidVotes.Insert(vote.GetHash(), vote);
     }
 
diff --git a/src/governance/object.cpp b/src/governance/object.cpp
index b482a0348964..c1b518b5fb4b 100644
--- a/src/governance/object.cpp
+++ b/src/governance/object.cpp
@@ -17,80 +17,42 @@
 
 #include <string>
 
-CGovernanceObject::CGovernanceObject() :
-    cs(),
-    nObjectType(GOVERNANCE_OBJECT_UNKNOWN),
-    nHashParent(),
-    nRevision(0),
-    nTime(0),
-    nDeletionTime(0),
-    nCollateralHash(),
-    vchData(),
-    masternodeOutpoint(),
-    vchSig(),
-    fCachedLocalValidity(false),
-    strLocalValidityError(),
-    fCachedFunding(false),
-    fCachedValid(true),
-    fCachedDelete(false),
-    fCachedEndorsed(false),
-    fDirtyCache(true),
-    fExpired(false),
-    fUnparsable(false),
-    mapCurrentMNVotes(),
-    fileVotes()
+CGovernanceObject::CGovernanceObject()
 {
     // PARSE JSON DATA STORAGE (VCHDATA)
     LoadData();
 }
 
 CGovernanceObject::CGovernanceObject(const uint256& nHashParentIn, int nRevisionIn, int64_t nTimeIn, const uint256& nCollateralHashIn, const std::string& strDataHexIn) :
-    cs(),
-    nObjectType(GOVERNANCE_OBJECT_UNKNOWN),
     nHashParent(nHashParentIn),
     nRevision(nRevisionIn),
     nTime(nTimeIn),
-    nDeletionTime(0),
     nCollateralHash(nCollateralHashIn),
-    vchData(ParseHex(strDataHexIn)),
-    masternodeOutpoint(),
-    vchSig(),
-    fCachedLocalValidity(false),
-    strLocalValidityError(),
-    fCachedFunding(false),
-    fCachedValid(true),
-    fCachedDelete(false),
-    fCachedEndorsed(false),
-    fDirtyCache(true),
-    fExpired(false),
-    fUnparsable(false),
-    mapCurrentMNVotes(),
-    fileVotes()
+    vchData(ParseHex(strDataHexIn))
 {
     // PARSE JSON DATA STORAGE (VCHDATA)
     LoadData();
 }
 
 CGovernanceObject::CGovernanceObject(const CGovernanceObject& other) :
-    cs(),
-    nObjectType(other.nObjectType),
+    nObjectType(other.nObjectType.load()),
     nHashParent(other.nHashParent),
-    nRevision(other.nRevision),
-    nTime(other.nTime),
-    nDeletionTime(other.nDeletionTime),
+    nRevision(other.nRevision.load()),
+    nTime(other.nTime.load()),
+    nDeletionTime(other.nDeletionTime.load()),
     nCollateralHash(other.nCollateralHash),
     vchData(other.vchData),
     masternodeOutpoint(other.masternodeOutpoint),
     vchSig(other.vchSig),
-    fCachedLocalValidity(other.fCachedLocalValidity),
+    fCachedLocalValidity(other.fCachedLocalValidity.load()),
     strLocalValidityError(other.strLocalValidityError),
-    fCachedFunding(other.fCachedFunding),
-    fCachedValid(other.fCachedValid),
-    fCachedDelete(other.fCachedDelete),
-    fCachedEndorsed(other.fCachedEndorsed),
-    fDirtyCache(other.fDirtyCache),
-    fExpired(other.fExpired),
-    fUnparsable(other.fUnparsable),
+    fCachedFunding(other.fCachedFunding.load()),
+    fCachedValid(other.fCachedValid.load()),
+    fCachedDelete(other.fCachedDelete.load()),
+    fCachedEndorsed(other.fCachedEndorsed.load()),
+    fDirtyCache(other.fDirtyCache.load()),
+    fExpired(other.fExpired.load()),
+    fUnparsable(other.fUnparsable.load()),
     mapCurrentMNVotes(other.mapCurrentMNVotes),
     fileVotes(other.fileVotes)
 {
@@ -279,6 +241,8 @@ uint256 CGovernanceObject::GetHash() const
 
     // CREATE HASH OF ALL IMPORTANT PIECES OF DATA
 
+    LOCK(cs);
+
     CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
     ss << nHashParent;
     ss << nRevision;
@@ -298,6 +262,7 @@ uint256 CGovernanceObject::GetSignatureHash() const
 
 void CGovernanceObject::SetMasternodeOutpoint(const COutPoint& outpoint)
 {
+    LOCK(cs);
     masternodeOutpoint = outpoint;
 }
 
@@ -307,12 +272,14 @@ bool CGovernanceObject::Sign(const CBLSSecretKey& key)
     if (!sig.IsValid()) {
         return false;
     }
+    LOCK(cs);
     vchSig = sig.ToByteVector();
     return true;
 }
 
 bool CGovernanceObject::CheckSignature(const CBLSPublicKey& pubKey) const
 {
+    LOCK(cs);
     if (!CBLSSignature(vchSig).VerifyInsecure(pubKey, GetSignatureHash())) {
         LogPrintf("CGovernanceObject::CheckSignature -- VerifyInsecure() failed\n");
         return false;
@@ -328,7 +295,7 @@ bool CGovernanceObject::CheckSignature(const CBLSPublicKey& pubKey) const
 UniValue CGovernanceObject::GetJSONObject() const
 {
     UniValue obj(UniValue::VOBJ);
-    if (vchData.empty()) {
+    if (LOCK(cs); vchData.empty()) {
         return obj;
     }
 
@@ -356,7 +323,7 @@ UniValue CGovernanceObject::GetJSONObject() const
 
 void CGovernanceObject::LoadData()
 {
-    if (vchData.empty()) {
+    if (LOCK(cs); vchData.empty()) {
         return;
     }
 
@@ -407,16 +374,19 @@ void CGovernanceObject::GetData(UniValue& objResult) const
 
 std::string CGovernanceObject::GetDataAsHexString() const
 {
+    LOCK(cs);
     return HexStr(vchData);
 }
 
 std::string CGovernanceObject::GetDataAsPlainString() const
 {
+    LOCK(cs);
     return std::string(vchData.begin(), vchData.end());
 }
 
 UniValue CGovernanceObject::ToJson() const
 {
+    LOCK(cs);
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("objectHash", GetHash().ToString());
     obj.pushKV("parentHash", nHashParent.ToString());
@@ -438,7 +408,7 @@ UniValue CGovernanceObject::ToJson() const
 
 void CGovernanceObject::UpdateLocalValidity()
 {
-    LOCK(cs_main);
+    LOCK(cs);
     // THIS DOES NOT CHECK COLLATERAL, THIS IS CHECKED UPON ORIGINAL ARRIVAL
     fCachedLocalValidity = IsValidLocally(strLocalValidityError, false);
 }
@@ -453,6 +423,7 @@ bool CGovernanceObject::IsValidLocally(std::string& strError, bool fCheckCollate
 
 bool CGovernanceObject::IsValidLocally(std::string& strError, bool& fMissingConfirmations, bool fCheckCollateral) const
 {
+    AssertLockHeld(cs);
     fMissingConfirmations = false;
 
     if (fUnparsable) {
@@ -470,7 +441,7 @@ bool CGovernanceObject::IsValidLocally(std::string& strError, bool& fMissingConf
             strError = strprintf("Invalid proposal data, error messages: %s", validator.GetErrorMessages());
             return false;
         }
-        if (fCheckCollateral && !IsCollateralValid(strError, fMissingConfirmations)) {
+        if (fCheckCollateral && !WITH_LOCK(cs_main, return IsCollateralValid(strError, fMissingConfirmations))) {
             strError = "Invalid proposal collateral";
             return false;
         }
@@ -531,7 +502,7 @@ bool CGovernanceObject::IsCollateralValid(std::string& strError, bool& fMissingC
 
     // RETRIEVE TRANSACTION IN QUESTION
 
-    if (!GetTransaction(nCollateralHash, txCollateral, Params().GetConsensus(), nBlockHash)) {
+    if (LOCK(cs); !GetTransaction(nCollateralHash, txCollateral, Params().GetConsensus(), nBlockHash)) {
         strError = strprintf("Can't find collateral tx %s", nCollateralHash.ToString());
         LogPrintf("CGovernanceObject::IsCollateralValid -- %s\n", strError);
         return false;
diff --git a/src/governance/object.h b/src/governance/object.h
index 196399688068..b752636fc129 100644
--- a/src/governance/object.h
+++ b/src/governance/object.h
@@ -93,67 +93,67 @@ class CGovernanceObject
 public: // Types
     using vote_m_t = std::map<COutPoint, vote_rec_t>;
 
-private:
     /// critical section to protect the inner data structures
     mutable CCriticalSection cs;
+private:
 
     /// Object typecode
-    int nObjectType;
+    std::atomic<int> nObjectType{GOVERNANCE_OBJECT_UNKNOWN};
 
     /// parent object, 0 is root
-    uint256 nHashParent;
+    uint256 nHashParent GUARDED_BY(cs);
 
     /// object revision in the system
-    int nRevision;
+    std::atomic<int> nRevision{0};
 
     /// time this object was created
-    int64_t nTime;
+    std::atomic<int64_t> nTime{0};
 
     /// time this object was marked for deletion
-    int64_t nDeletionTime;
+    std::atomic<int64_t> nDeletionTime{0};
 
     /// fee-tx
-    uint256 nCollateralHash;
+    uint256 nCollateralHash GUARDED_BY(cs);
 
     /// Data field - can be used for anything
-    std::vector<unsigned char> vchData;
+    std::vector<unsigned char> vchData GUARDED_BY(cs);
 
     /// Masternode info for signed objects
-    COutPoint masternodeOutpoint;
-    std::vector<unsigned char> vchSig;
+    COutPoint masternodeOutpoint GUARDED_BY(cs);
+    std::vector<unsigned char> vchSig GUARDED_BY(cs);
 
     /// is valid by blockchain
-    bool fCachedLocalValidity;
-    std::string strLocalValidityError;
+    std::atomic<bool> fCachedLocalValidity{false};
+    std::string strLocalValidityError GUARDED_BY(cs);
 
     // VARIOUS FLAGS FOR OBJECT / SET VIA MASTERNODE VOTING
 
     /// true == minimum network support has been reached for this object to be funded (doesn't mean it will for sure though)
-    bool fCachedFunding;
+    std::atomic<bool> fCachedFunding{false};
 
     /// true == minimum network has been reached flagging this object as a valid and understood governance object (e.g, the serialized data is correct format, etc)
-    bool fCachedValid;
+    std::atomic<bool> fCachedValid{true};
 
     /// true == minimum network support has been reached saying this object should be deleted from the system entirely
-    bool fCachedDelete;
+    std::atomic<bool> fCachedDelete{false};
 
     /** true == minimum network support has been reached flagging this object as endorsed by an elected representative body
      * (e.g. business review board / technical review board /etc)
      */
-    bool fCachedEndorsed;
+    std::atomic<bool> fCachedEndorsed{false};
 
     /// object was updated and cached values should be updated soon
-    bool fDirtyCache;
+    std::atomic<bool> fDirtyCache{false};
 
     /// Object is no longer of interest
-    bool fExpired;
+    std::atomic<bool> fExpired{false};
 
     /// Failed to parse object data
-    bool fUnparsable;
+    std::atomic<bool> fUnparsable{false};
 
-    vote_m_t mapCurrentMNVotes;
+    vote_m_t mapCurrentMNVotes GUARDED_BY(cs);
 
-    CGovernanceObjectVoteFile fileVotes;
+    CGovernanceObjectVoteFile fileVotes GUARDED_BY(cs);
 
 public:
     CGovernanceObject();
@@ -179,13 +179,15 @@ class CGovernanceObject
         return nObjectType;
     }
 
-    const uint256& GetCollateralHash() const
+    uint256 GetCollateralHash() const
     {
+        LOCK(cs);
         return nCollateralHash;
     }
 
-    const COutPoint& GetMasternodeOutpoint() const
+    COutPoint GetMasternodeOutpoint() const
     {
+        LOCK(cs);
         return masternodeOutpoint;
     }
 
@@ -224,8 +226,12 @@ class CGovernanceObject
         fExpired = true;
     }
 
-    const CGovernanceObjectVoteFile& GetVoteFile() const
+    /* TODO we are returning an expensive copy here. Refactor this code to avoid copy, while retaining saftey.
+     * Likely this will include making CGovernanceObjectVoteFile internally safe and returning a ptr or ref
+    */
+    CGovernanceObjectVoteFile GetVoteFile() const
     {
+        LOCK(cs);
         return fileVotes;
     }
 
@@ -239,12 +245,12 @@ class CGovernanceObject
 
     // CORE OBJECT FUNCTIONS
 
-    bool IsValidLocally(std::string& strError, bool fCheckCollateral) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    bool IsValidLocally(std::string& strError, bool fCheckCollateral) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
-    bool IsValidLocally(std::string& strError, bool& fMissingConfirmations, bool fCheckCollateral) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    bool IsValidLocally(std::string& strError, bool& fMissingConfirmations, bool fCheckCollateral) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /// Check the collateral transaction for the budget proposal/finalized budget
-    bool IsCollateralValid(std::string& strError, bool& fMissingConfirmations) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    bool IsCollateralValid(std::string& strError, bool& fMissingConfirmations) const EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
 
     void UpdateLocalValidity();
 
@@ -288,6 +294,7 @@ class CGovernanceObject
     SERIALIZE_METHODS(CGovernanceObject, obj)
     {
         // SERIALIZE DATA FOR SAVING/LOADING OR NETWORK FUNCTIONS
+        LOCK(obj.cs);
         READWRITE(
                 obj.nHashParent,
                 obj.nRevision,