diff --git a/consensus/XDPoS/engines/engine_v2/engine.go b/consensus/XDPoS/engines/engine_v2/engine.go
index 29ebd8b04b..c223d406d4 100644
--- a/consensus/XDPoS/engines/engine_v2/engine.go
+++ b/consensus/XDPoS/engines/engine_v2/engine.go
@@ -7,6 +7,7 @@ import (
 	"math/big"
 	"os"
 	"path/filepath"
+	"strconv"
 	"sync"
 	"time"
 
@@ -66,6 +67,9 @@ type XDPoS_v2 struct {
 	highestTimeoutCert *types.TimeoutCert
 	highestCommitBlock *types.BlockInfo
 
+	latestReward         map[string]interface{}
+	latestRewardBlocknum uint64
+
 	HookReward  func(chain consensus.ChainReader, state *state.StateDB, parentState *state.StateDB, header *types.Header) (map[string]interface{}, error)
 	HookPenalty func(chain consensus.ChainReader, number *big.Int, parentHash common.Hash, candidates []common.Address) ([]common.Address, error)
 
@@ -402,14 +406,34 @@ func (x *XDPoS_v2) Finalize(chain consensus.ChainReader, header *types.Header, s
 		if err != nil {
 			return nil, err
 		}
-		if len(common.StoreRewardFolder) > 0 {
-			data, err := json.Marshal(rewards)
-			if err == nil {
-				err = os.WriteFile(filepath.Join(common.StoreRewardFolder, header.Number.String()+"."+header.Hash().Hex()), data, 0644)
-			}
-			if err != nil {
-				log.Error("Error when save reward info ", "number", header.Number, "hash", header.Hash().Hex(), "err", err)
-			}
+
+		x.signLock.RLock()
+		signer := x.signer
+		x.signLock.RUnlock()
+		x.lock.Lock()
+		x.latestRewardBlocknum = header.Number.Uint64()
+		x.latestReward, err = deepCloneJSON(rewards)
+		x.lock.Unlock()
+		if err != nil {
+			log.Error("[Finalize] Error deep cloning latest reward", "err", err, "rewards", rewards)
+			return nil, err
+		}
+
+		var decodedExtraField types.ExtraFields_v2
+		err = utils.DecodeBytesExtraFields(header.Extra, &decodedExtraField)
+		if err != nil {
+			log.Error("[Finalize] Error when decode extra field to get the round number", "Hash", header.Hash().Hex(), "Number", header.Number.Uint64(), "Error", err)
+		}
+
+		parentHeader := chain.GetHeaderByHash(header.ParentHash)
+		isMyTurn, err := x.yourturn(chain, decodedExtraField.Round, parentHeader, signer)
+		if err != nil {
+			log.Error("[Finalize] Error checking myturn", "err", err, "round", decodedExtraField.Round, "signer", signer, "parentHeader", parentHeader)
+			return nil, err
+		}
+
+		if !isMyTurn { // if myturn use Seal to save file
+			x.saveRewardToFile(header.Hash(), header.Number.Uint64())
 		}
 	}
 
@@ -470,6 +494,24 @@ func (x *XDPoS_v2) Seal(chain consensus.ChainReader, block *types.Block, stop <-
 		log.Error("[Seal] Error when decode extra field to get the round number from v2 block during sealing", "Hash", header.Hash().Hex(), "Number", header.Number.Uint64(), "Error", err)
 		return nil, err
 	}
+
+	isEpochSwitch, _, err := x.IsEpochSwitch(header)
+	if err != nil {
+		log.Error("[Seal] IsEpochSwitch bug!", "err", err)
+		return nil, err
+	}
+	if isEpochSwitch {
+		parentHeader := chain.GetHeaderByHash(header.ParentHash)
+		isMyTurn, err := x.yourturn(chain, decodedExtraField.Round, parentHeader, signer)
+
+		if err != nil {
+			log.Error("[Seal] Error checking myturn", "err", err, "round", decodedExtraField.Round, "signer", signer, "parentHeader", parentHeader)
+			return nil, err
+		}
+		if isMyTurn { // if not myturn use Finalize to save file
+			x.saveRewardToFile(header.Hash(), header.Number.Uint64())
+		}
+	}
 	x.highestSelfMinedRound = decodedExtraField.Round
 
 	return block.WithSeal(header), nil
@@ -1017,3 +1059,57 @@ func (x *XDPoS_v2) periodicJob() {
 func (x *XDPoS_v2) GetLatestCommittedBlockInfo() *types.BlockInfo {
 	return x.highestCommitBlock
 }
+
+func (x *XDPoS_v2) saveRewardToFile(blockHash common.Hash, blockNumber uint64) {
+	if len(common.StoreRewardFolder) == 0 {
+		log.Info("[saveRewardToFile] Skip saving reward to file", "len(common.StoreRewardFolder)", len(common.StoreRewardFolder))
+		return
+	}
+
+	x.lock.RLock()
+	rewardsBlocknum := x.latestRewardBlocknum
+	rewards, err := deepCloneJSON(x.latestReward)
+	x.lock.RUnlock()
+	if err != nil {
+		log.Error("[saveRewardToFile] Error deep cloning latest reward", "err", err)
+		return
+	}
+
+	if rewardsBlocknum != blockNumber {
+		log.Error("[saveRewardToFile] Error blocknumber mismatch with latest reward state, this should not happen!!", "rewardsBlocknum", rewardsBlocknum, "blockNumber", blockNumber)
+		return
+	}
+
+	data, err := json.Marshal(rewards)
+	if err != nil {
+		log.Error("[saveRewardToFile] Error Marshalling rewards", "err", err, "rewards", rewards)
+		return
+	}
+
+	filename := strconv.FormatUint(blockNumber, 10) + "." + blockHash.Hex()
+	err = os.WriteFile(filepath.Join(common.StoreRewardFolder, filename), data, 0644)
+	if err != nil {
+		log.Error("[saveRewardToFile] Error when writing reward info", "filename", filename, "rewards", string(data), "err", err)
+		return
+	}
+
+	log.Debug("[saveRewardToFile] Saved rewards", "filename", filename)
+	log.Debug("[saveRewardToFile] Saved rewards", "rewards", string(data))
+
+	return
+}
+
+func deepCloneJSON(original map[string]interface{}) (map[string]interface{}, error) {
+	data, err := json.Marshal(original)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal: %w", err)
+	}
+
+	var cloned map[string]interface{}
+	err = json.Unmarshal(data, &cloned)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal: %w", err)
+	}
+
+	return cloned, nil
+}