diff --git a/consensus/consortium/v2/api.go b/consensus/consortium/v2/api.go
index a168eeb164..3ac0167e5f 100644
--- a/consensus/consortium/v2/api.go
+++ b/consensus/consortium/v2/api.go
@@ -52,8 +52,7 @@ func (api *consortiumV2Api) GetFinalityVoteAtHash(hash common.Hash) (*finalityVo
 		return nil, consortiumCommon.ErrUnknownBlock
 	}
 
-	isShillin := api.consortium.chainConfig.IsShillin(header.Number)
-	extraData, err := finality.DecodeExtra(header.Extra, isShillin)
+	extraData, err := finality.DecodeExtraV2(header.Extra, api.consortium.chainConfig, header.Number)
 	if err != nil {
 		return nil, err
 	}
diff --git a/consensus/consortium/v2/consortium.go b/consensus/consortium/v2/consortium.go
index 0b91785870..1745260a39 100644
--- a/consensus/consortium/v2/consortium.go
+++ b/consensus/consortium/v2/consortium.go
@@ -359,7 +359,7 @@ func (c *Consortium) verifyCascadingFields(chain consensus.ChainHeaderReader, he
 
 	// Check extra data
 	isShillin := c.chainConfig.IsShillin(header.Number)
-	extraData, err := finality.DecodeExtra(header.Extra, isShillin)
+	extraData, err := finality.DecodeExtraV2(header.Extra, c.chainConfig, header.Number)
 	if err != nil {
 		return err
 	}
@@ -726,7 +726,6 @@ func (c *Consortium) Prepare(chain consensus.ChainHeaderReader, header *types.He
 	// Set the correct difficulty
 	header.Difficulty = CalcDifficulty(snap, coinbase)
 
-	isShillin := c.chainConfig.IsShillin(header.Number)
 	var extraData finality.HeaderExtraData
 
 	if number%c.config.EpochV2 == 0 || c.chainConfig.IsOnConsortiumV2(big.NewInt(int64(number))) {
@@ -741,7 +740,10 @@ func (c *Consortium) Prepare(chain consensus.ChainHeaderReader, header *types.He
 	// not assemble finality vote yet. Let's wait some time for the
 	// finality votes to be broadcasted around the network. The
 	// finality votes are assembled later in Seal function.
-	header.Extra = extraData.Encode(isShillin)
+	header.Extra, err = extraData.EncodeV2(c.chainConfig, header.Number)
+	if err != nil {
+		return err
+	}
 
 	// Mix digest is reserved for now, set to empty
 	header.MixDigest = common.Hash{}
@@ -767,9 +769,10 @@ func (c *Consortium) processSystemTransactions(chain consensus.ChainHeaderReader
 	_, _, _, contract := c.readSignerAndContract()
 
 	// If the parent's block includes the finality votes, distribute reward for the voters
-	if c.chainConfig.IsShillin(new(big.Int).Sub(header.Number, common.Big1)) {
+	parentNumber := new(big.Int).Sub(header.Number, common.Big1)
+	if c.chainConfig.IsShillin(parentNumber) {
 		parentHeader := chain.GetHeader(header.ParentHash, header.Number.Uint64()-1)
-		extraData, err := finality.DecodeExtra(parentHeader.Extra, true)
+		extraData, err := finality.DecodeExtraV2(parentHeader.Extra, c.chainConfig, parentNumber)
 		if err != nil {
 			return err
 		}
@@ -891,7 +894,7 @@ func (c *Consortium) Finalize(chain consensus.ChainHeaderReader, header *types.H
 		if err != nil {
 			return err
 		}
-		extraData, err := finality.DecodeExtra(header.Extra, isShillin)
+		extraData, err := finality.DecodeExtraV2(header.Extra, c.chainConfig, header.Number)
 		if err != nil {
 			return err
 		}
@@ -1097,9 +1100,15 @@ func (c *Consortium) SealHash(header *types.Header) common.Hash {
 		// FinalizeAndAssemble call.
 		copyHeader := types.CopyHeader(header)
 
-		extraData, _ := finality.DecodeExtra(copyHeader.Extra, true)
+		extraData, err := finality.DecodeExtraV2(copyHeader.Extra, c.chainConfig, header.Number)
+		if err != nil {
+			log.Error("Failed to decode header extra data", "err", err)
+		}
 		extraData.HasFinalityVote = 0
-		copyHeader.Extra = extraData.Encode(true)
+		copyHeader.Extra, err = extraData.EncodeV2(c.chainConfig, header.Number)
+		if err != nil {
+			log.Error("Failed to encode header extra data", "err", err)
+		}
 		return calculateSealHash(copyHeader, c.chainConfig.ChainID)
 	} else {
 		return calculateSealHash(header, c.chainConfig.ChainID)
@@ -1263,7 +1272,7 @@ func (c *Consortium) assembleFinalityVote(header *types.Header, snap *Snapshot)
 
 				bitSetCount := len(finalityVotedValidators.Indices())
 				if bitSetCount >= finalityThreshold {
-					extraData, err := finality.DecodeExtra(header.Extra, true)
+					extraData, err := finality.DecodeExtraV2(header.Extra, c.chainConfig, header.Number)
 					if err != nil {
 						// This should not happen
 						log.Error("Failed to decode header extra data", "err", err)
@@ -1272,7 +1281,11 @@ func (c *Consortium) assembleFinalityVote(header *types.Header, snap *Snapshot)
 					extraData.HasFinalityVote = 1
 					extraData.FinalityVotedValidators = finalityVotedValidators
 					extraData.AggregatedFinalityVotes = blst.AggregateSignatures(signatures)
-					header.Extra = extraData.Encode(true)
+					header.Extra, err = extraData.EncodeV2(c.chainConfig, header.Number)
+					if err != nil {
+						log.Error("Failed to encode header extra data", "err", err)
+						return
+					}
 				}
 			}
 		}
diff --git a/consensus/consortium/v2/consortium_test.go b/consensus/consortium/v2/consortium_test.go
index 59c10c0c87..fe345a4918 100644
--- a/consensus/consortium/v2/consortium_test.go
+++ b/consensus/consortium/v2/consortium_test.go
@@ -3,8 +3,10 @@ package v2
 import (
 	"bytes"
 	"crypto/ecdsa"
+	"crypto/rand"
 	"encoding/binary"
 	"errors"
+	"io"
 	"math/big"
 	"testing"
 	"time"
@@ -530,6 +532,173 @@ func TestExtraDataDecode(t *testing.T) {
 	}
 }
 
+func mockExtraData(nVal int, bits uint32) *finality.HeaderExtraData {
+	var (
+		finalityVotedValidators finality.FinalityVoteBitSet
+		aggregatedFinalityVotes blsCommon.Signature
+		checkpointValidators    []finality.ValidatorWithBlsPub
+		seal                    = make([]byte, finality.ExtraSeal)
+		ret                     = &finality.HeaderExtraData{}
+	)
+
+	bits = bits % 7 // ensure bits can be represented by 3-bit integer
+	for i := 0; i < 3; i++ {
+		if bits&(1<<i) != 0 {
+			switch i {
+			case 0:
+				ret.HasFinalityVote = 1
+				finalityVotedValidators = finality.FinalityVoteBitSet(uint64(8))
+				ret.FinalityVotedValidators = finalityVotedValidators
+
+				delegated, _ := blst.RandKey()
+				msg := make([]byte, 64)
+				rand.Read(msg)
+				aggregatedFinalityVotes = delegated.Sign(msg)
+				ret.AggregatedFinalityVotes = aggregatedFinalityVotes
+			case 1:
+				for i := 0; i < nVal; i++ {
+					s, _ := blst.RandKey()
+					sk, _ := ecdsa.GenerateKey(crypto.S256(), rand.Reader)
+					addr := crypto.PubkeyToAddress(sk.PublicKey)
+					val := finality.ValidatorWithBlsPub{
+						Address:      addr,
+						BlsPublicKey: s.PublicKey(),
+					}
+					checkpointValidators = append(checkpointValidators, val)
+				}
+				ret.CheckpointValidators = checkpointValidators
+			case 2:
+				// Even seal does not get assigned a random value, seal
+				// is still be zero-filled byte array of size ExtraSeal
+				rand.Read(seal)
+				ret.Seal = [finality.ExtraSeal]byte(seal)
+			}
+		}
+	}
+	return ret
+}
+
+func TestExtraDataEncodeRLP(t *testing.T) {
+	nVal := 22
+	for i := 0; i < 7; i++ {
+		ext := mockExtraData(nVal, uint32(i))
+		enc, err := ext.EncodeRLP()
+		if err != nil {
+			t.Errorf("encode rlp error: %v", err)
+		}
+		if len(enc) < finality.ExtraSeal {
+			t.Error("encode rlp error: invalid length of encoded data")
+		}
+	}
+
+	var extraData finality.HeaderExtraData
+	extraData.HasFinalityVote = 2
+	_, err := extraData.EncodeRLP()
+	if !errors.Is(err, finality.ErrInvalidHasFinalityVote) {
+		t.Fatalf("Expect error: %s, got: %s", finality.ErrInvalidHasFinalityVote, err)
+	}
+}
+
+func TestExtraDataDecodeRLP(t *testing.T) {
+	nVals := 22
+	// loop 64 times, equivalent to 64 combinations of 6 bits
+	for i := 0; i < 7; i++ {
+		ext := mockExtraData(nVals, uint32(i))
+		enc, err := ext.EncodeRLP()
+		if err != nil {
+			t.Errorf("encode rlp error: %v", err)
+		}
+		dec, err := finality.DecodeExtraRLP(enc)
+		if err != nil {
+			t.Errorf("decode rlp error: %v", err)
+		}
+		if !bytes.Equal(dec.Vanity[:], ext.Vanity[:]) {
+			t.Errorf("Mismatched decoded data")
+		}
+		if dec.FinalityVotedValidators != ext.FinalityVotedValidators {
+			t.Errorf("Mismatch decoded data")
+		}
+		if (dec.AggregatedFinalityVotes != nil && ext.AggregatedFinalityVotes == nil) ||
+			(dec.AggregatedFinalityVotes == nil && ext.AggregatedFinalityVotes != nil) {
+			t.Errorf("Mismatch decoded data")
+		}
+		if dec.AggregatedFinalityVotes != nil &&
+			ext.AggregatedFinalityVotes != nil &&
+			!bytes.Equal(dec.AggregatedFinalityVotes.Marshal(), ext.AggregatedFinalityVotes.Marshal()) {
+			t.Errorf("Mismatch decoded data")
+		}
+		if len(dec.CheckpointValidators) != len(ext.CheckpointValidators) {
+			t.Errorf("Mismatch decoded data")
+		}
+		for i := 0; i < len(ext.CheckpointValidators); i++ {
+			if dec.CheckpointValidators[i].Address.Hex() != ext.CheckpointValidators[i].Address.Hex() {
+				t.Errorf("Mismatch decoded data")
+			}
+			if (dec.CheckpointValidators[i].BlsPublicKey == nil && ext.CheckpointValidators[i].BlsPublicKey != nil) ||
+				(dec.CheckpointValidators[i].BlsPublicKey != nil && ext.CheckpointValidators[i].BlsPublicKey == nil) {
+				t.Errorf("Mismatch decoded data")
+			}
+			if dec.CheckpointValidators[i].BlsPublicKey != nil &&
+				ext.CheckpointValidators[i].BlsPublicKey != nil &&
+				!bytes.Equal(dec.CheckpointValidators[i].BlsPublicKey.Marshal(), ext.CheckpointValidators[i].BlsPublicKey.Marshal()) {
+				t.Errorf("Mismatch decoded data")
+			}
+		}
+		if !bytes.Equal(dec.Seal[:], ext.Seal[:]) {
+			t.Errorf("Mismatch decoded data")
+		}
+	}
+
+	_, err := finality.DecodeExtraRLP([]byte{})
+	if !errors.Is(err, finality.ErrInvalidEncodedExtraData) {
+		t.Fatalf("Expect error: %s, got: %s", finality.ErrInvalidEncodedExtraData, err)
+	}
+
+	encodedData := [finality.ExtraSeal]byte{}
+	_, err = finality.DecodeExtraRLP(encodedData[:])
+	if !errors.Is(err, io.EOF) {
+		t.Fatalf("Expect error: %s, got: %s", io.EOF, err)
+	}
+}
+
+func BenchmarkEncodeRLP(b *testing.B) {
+	nVal := 22
+	ext := mockExtraData(nVal, 7)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ext.EncodeRLP()
+	}
+}
+
+func BenchmarkEncode(b *testing.B) {
+	nVal := 22
+	ext := mockExtraData(nVal, 7)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ext.Encode(true)
+	}
+}
+
+func BenchmarkDecodeRLP(b *testing.B) {
+	nVal := 22
+	ext := mockExtraData(nVal, 7)
+	dec, _ := ext.EncodeRLP()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		finality.DecodeExtraRLP(dec)
+	}
+}
+
+func BenchmarkDecode(b *testing.B) {
+	nVal := 22
+	ext := mockExtraData(nVal, 7)
+	dec := ext.Encode(true)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		finality.DecodeExtra(dec, true)
+	}
+}
+
 func TestVerifyFinalitySignature(t *testing.T) {
 	const numValidator = 3
 	var err error
diff --git a/consensus/consortium/v2/finality/consortium_header.go b/consensus/consortium/v2/finality/consortium_header.go
index e19e85ed15..9bb4640ebf 100644
--- a/consensus/consortium/v2/finality/consortium_header.go
+++ b/consensus/consortium/v2/finality/consortium_header.go
@@ -6,12 +6,14 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"errors"
+	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/crypto/bls/blst"
 	blsCommon "github.com/ethereum/go-ethereum/crypto/bls/common"
 	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/rlp"
 )
 
 const (
@@ -66,6 +68,14 @@ var (
 	// ErrInvalidTargetNumber is returned if the vote contains invalid
 	// target number
 	ErrInvalidTargetNumber = errors.New("invalid target number in vote")
+
+	// ErrInvalidExtraData is returned if the bls public key is nil
+	ErrInvalidExtraData = errors.New("invalid header extra data")
+
+	// ErrInvalidArgument is returned if the chain config is nil
+	ErrInvalidArgument = errors.New("invalid argument")
+
+	ErrInvalidEncodedExtraData = errors.New("invalid encoded extra data")
 )
 
 type ValidatorWithBlsPub struct {
@@ -248,6 +258,119 @@ func DecodeExtra(rawBytes []byte, isShillin bool) (*HeaderExtraData, error) {
 	return &extraData, nil
 }
 
+// extraDataRLP excludes vanity, hasFinalityVotes because vanity is not used in
+// Consortium and filled with zero by default; whereas hasFinalityVotes can be determined
+// by AggregatedFinalityVotes and FinalityVotedValidators. On the other hand, seal is 
+// appended manually, enabling encodeSigHeader easily to exclude Seal before signing process
+type extraDataRLP struct {
+	FinalityVotedValidators FinalityVoteBitSet
+	AggregatedFinalityVotes []byte
+	CheckpointValidators    []validatorWithBlsPubRLP
+}
+
+type validatorWithBlsPubRLP struct {
+	Address      common.Address
+	BlsPublicKey []byte
+}
+
+// EncodeRLP computes rlp-based encoding for HeaderExtraData before
+// appending Seal manually, enabling encodeSigHeader easily to exclude
+// Seal before signing process.
+func (extraData *HeaderExtraData) EncodeRLP() ([]byte, error) {
+	var ext = &extraDataRLP{}
+	if extraData.HasFinalityVote != 0 && extraData.HasFinalityVote != 1 {
+		return nil, ErrInvalidHasFinalityVote
+	}
+	if extraData.HasFinalityVote == 1 {
+		if extraData.AggregatedFinalityVotes == nil || len(extraData.FinalityVotedValidators.Indices()) == 0 {
+			return nil, ErrInvalidExtraData
+		}
+		ext.FinalityVotedValidators = extraData.FinalityVotedValidators
+		ext.AggregatedFinalityVotes = extraData.AggregatedFinalityVotes.Marshal()
+	}
+
+	cp := make([]validatorWithBlsPubRLP, len(extraData.CheckpointValidators))
+	for i, val := range extraData.CheckpointValidators {
+		if val.BlsPublicKey == nil {
+			return nil, ErrInvalidExtraData
+		}
+		cp[i] = validatorWithBlsPubRLP{
+			Address:      val.Address,
+			BlsPublicKey: val.BlsPublicKey.Marshal(),
+		}
+	}
+	ext.CheckpointValidators = cp
+
+	enc, err := rlp.EncodeToBytes(ext)
+	if err != nil {
+		return nil, err
+	}
+	// Seal is appended at the end of the raw bytes data
+	rawBytes := append(enc, extraData.Seal[:]...)
+	return rawBytes, nil
+}
+
+// DecodeExtraRLP decodes HeaderExtraData from bytes. It is necessary to exclude
+// the last ExtraSeal bytes before rlp-decoding, as Seal is not rlp encoded.
+func DecodeExtraRLP(enc []byte) (*HeaderExtraData, error) {
+	var (
+		err error
+		dec = &extraDataRLP{}
+		ret = &HeaderExtraData{}
+	)
+	if len(enc) < ExtraSeal {
+		return nil, ErrInvalidEncodedExtraData
+	}
+	// Exclude the seal before rlp decoding.
+	if err := rlp.DecodeBytes(enc[:len(enc)-ExtraSeal], dec); err != nil {
+		return nil, err
+	}
+	cp := make([]ValidatorWithBlsPub, len(dec.CheckpointValidators))
+	for i, val := range dec.CheckpointValidators {
+		blsPublicKey, err := blst.PublicKeyFromBytes(val.BlsPublicKey)
+		if err != nil {
+			return nil, err
+		}
+		cp[i] = ValidatorWithBlsPub{
+			Address:      val.Address,
+			BlsPublicKey: blsPublicKey,
+		}
+	}
+	ret.CheckpointValidators = cp
+	if len(dec.AggregatedFinalityVotes) != 0 && len(dec.FinalityVotedValidators.Indices()) != 0 {
+		ret.HasFinalityVote = 1
+		ret.FinalityVotedValidators = dec.FinalityVotedValidators
+		ret.AggregatedFinalityVotes, err = blst.SignatureFromBytes(dec.AggregatedFinalityVotes)
+		if err != nil {
+			return nil, err
+		}
+	}
+	copy(ret.Seal[:], enc[len(enc)-ExtraSeal:])
+	return ret, nil
+}
+
+// After Tripp, HeaderExtraData switches to use RLP encoding method
+func (extraData *HeaderExtraData) EncodeV2(chainConfig *params.ChainConfig, number *big.Int) ([]byte, error) {
+	if chainConfig == nil || number == nil {
+		return nil, ErrInvalidArgument
+	}
+	if chainConfig.IsTripp(number) {
+		return extraData.EncodeRLP()
+	}
+	return extraData.Encode(chainConfig.IsShillin(number)), nil
+}
+
+// After Tripp, HeaderExtraData switches to use RLP decoding method
+func DecodeExtraV2(enc []byte, chainConfig *params.ChainConfig, number *big.Int) (*HeaderExtraData, error) {
+	if chainConfig == nil || number == nil {
+		return nil, ErrInvalidArgument
+	}
+	if chainConfig.IsTripp(number) {
+		return DecodeExtraRLP(enc)
+	}
+	return DecodeExtra(enc, chainConfig.IsShillin(number))
+}
+
 // ParseCheckpointData retrieves the list of validator addresses and finality voter's public keys
 // at the checkpoint block
 func ParseCheckpointData(checkpointData []byte, isShillin bool) ([]ValidatorWithBlsPub, error) {
diff --git a/consensus/consortium/v2/snapshot.go b/consensus/consortium/v2/snapshot.go
index 5931f0713a..1e586fb604 100644
--- a/consensus/consortium/v2/snapshot.go
+++ b/consensus/consortium/v2/snapshot.go
@@ -205,7 +205,7 @@ func (s *Snapshot) apply(headers []*types.Header, chain consensus.ChainHeaderRea
 		snap.Recents[number] = validator
 
 		if chain.Config().IsShillin(header.Number) {
-			extraData, err := finality.DecodeExtra(header.Extra, true)
+			extraData, err := finality.DecodeExtraV2(header.Extra, chain.Config(), header.Number)
 			if err != nil {
 				return nil, err
 			}
@@ -240,7 +240,7 @@ func (s *Snapshot) apply(headers []*types.Header, chain consensus.ChainHeaderRea
 			} else {
 				isShillin := chain.Config().IsShillin(checkpointHeader.Number)
 				// Get validator set from headers and use that for new validator set
-				extraData, err := finality.DecodeExtra(checkpointHeader.Extra, isShillin)
+				extraData, err := finality.DecodeExtraV2(checkpointHeader.Extra, chain.Config(), checkpointHeader.Number)
 				if err != nil {
 					return nil, err
 				}
diff --git a/monitor/finality_vote.go b/monitor/finality_vote.go
index 6edd7af64a..c833f1bc10 100644
--- a/monitor/finality_vote.go
+++ b/monitor/finality_vote.go
@@ -64,7 +64,7 @@ func prettyPrintAddress(addresses []common.Address) string {
 }
 
 func (monitor *FinalityVoteMonitor) CheckFinalityVote(block *types.Block) error {
-	extraData, err := finality.DecodeExtra(block.Extra(), true)
+	extraData, err := finality.DecodeExtraV2(block.Extra(), monitor.chain.Config(), block.Number())
 	// This should not happen because the block has been verified
 	if err != nil {
 		log.Error("Unexpected error when decode extradata", "err", err)