Stop Limit Order on SPX option constantly gives worse fill than reality

from datetime import datetime, timedelta
from typing import Optional, List

def round_to_nearest_0_05(price: float) -> float:
    return round(round(price / 0.05) * 0.05, 1)

def estimate_pss(short_leg: OptionContract,
                 short_leg_fill_price: float,
                 long_leg: OptionContract,
                 long_leg_fill_price: float,
                 net_spread_value: float) -> float:
    return short_leg_fill_price + (net_spread_value - (short_leg_fill_price - long_leg_fill_price)) / (
        1 - long_leg.greeks.delta / short_leg.greeks.delta
    )

class IronCondor:
    class BeStopPrice:
        def __init__(self,
                     short_leg: OptionContract,
                     short_leg_fill_price: float,
                     long_leg: OptionContract,
                     long_leg_fill_price: float,
                     this_side_premium: float,
                     other_side_premium: float,
                     elapsed_stop_time: Optional[timedelta] = None,
                     short_leg_stop_price: Optional[float] = None,
                     stop_out_type: Optional[OrderType] = None,
                     long_leg_sell_price: Optional[float] = None,
                     short_leg_market_price_on_stop: Optional[float] = None,
                     long_leg_market_price_on_stop: Optional[float] = None
                     ):
            self.is_call = "C" in short_leg.symbol.value
            self.short_leg = short_leg
            self.long_leg = long_leg
            self.short_leg_fill_price = short_leg_fill_price
            self.long_leg_fill_price = long_leg_fill_price
            self.this_side_premium = this_side_premium
            self.other_side_premium = other_side_premium
            self.be_stop_price = round_to_nearest_0_05(
                estimate_pss(short_leg, short_leg_fill_price, long_leg, long_leg_fill_price, this_side_premium + other_side_premium)
            )
            self.stop_limit_price = round_to_nearest_0_05(
                self.be_stop_price + 0.2 if self.is_call else self.be_stop_price + 0.3)
            self.stop_market_price = round_to_nearest_0_05(
                self.stop_limit_price + 0.3)
            self.take_profit = 0.00
            self.elpased_stop_time = elapsed_stop_time
            self.short_leg_stop_price = short_leg_stop_price
            self.stop_out_type = stop_out_type
            self.long_leg_sell_price = long_leg_sell_price
            self.short_leg_market_price_on_stop = short_leg_market_price_on_stop
            self.long_leg_market_price_on_stop = long_leg_market_price_on_stop

        def _get_short_leg_loss(self) -> float:
            if self.this_side_premium < self.other_side_premium:
                return 2 * self.this_side_premium
            else:
                return self.other_side_premium + self.this_side_premium

        def get_long_leg_limit_price_on_stop(self) -> float:
            assert (self.short_leg_stop_price is not None)
            slippage = min(self.stop_slippage(), 0.3)
            return round_to_nearest_0_05(self.short_leg_stop_price - self.this_side_premium - self.other_side_premium)

        def is_stopped_out(self) -> bool:
            return self.short_leg_stop_price is not None

        def stop_slippage(self) -> float:
            assert (self.short_leg_stop_price is not None)
            return self.short_leg_stop_price - self.be_stop_price

        def realized_pl(self) -> float:
            pl = self.short_leg_fill_price - self.long_leg_fill_price
            if self.short_leg_stop_price is not None:
                pl -= self.short_leg_stop_price
            if self.long_leg_sell_price is not None:
                pl += self.long_leg_sell_price
            return pl

        def debug_messages(self) -> List[str]:
            type = "CALL" if self.is_call else "PUT"
            message = [f"{type} realized p/l: {(self.realized_pl()):+.2f}"]
            if self.is_stopped_out() and self.elpased_stop_time is not None:
                hours = self.elpased_stop_time.total_seconds() // 3600
                minutes = (self.elpased_stop_time.total_seconds() % 3600) // 60
                message += [f", Stop-Out {int(hours)}h:{int(minutes)}m by {self.stop_out_type}, expected in [{self.be_stop_price}:{self.stop_limit_price}:{self.stop_market_price}], actual: {self.short_leg_stop_price}, stop_slippage: {(self.stop_slippage()):+.2f}"]
                message += [f", short_leg_market_price_on_stop: {self.short_leg_market_price_on_stop}, long_leg_market_price_on_stop: {self.long_leg_market_price_on_stop} "]
                if self.long_leg_sell_price is not None:
                    message += [f", long_leg_sell_price: {self.long_leg_sell_price:.2f}"]
                else:
                    message += [f"UNABLE to sell long leg at {self.get_long_leg_limit_price_on_stop()}!!!"]
            return message

    def __init__(self, quantity: int,
                 short_call: OptionContract,
                 long_call: OptionContract,
                 short_put: OptionContract,
                 long_put: OptionContract,
                 entry_time: datetime,
                 stop_limit_order_fn,
                 stop_market_order_fn,
                 limit_order_fn,
                 market_order_fn,
                 get_current_price
                 ):
        self.quantity = quantity
        self.short_call = short_call
        self.long_call = long_call
        self.short_put = short_put
        self.long_put = long_put
        self.entry_time = entry_time
        self.stop_limit_order_fn = stop_limit_order_fn
        self.stop_market_order_fn = stop_market_order_fn
        self.limit_order_fn = limit_order_fn
        self.market_order_fn = market_order_fn
        self.get_current_price = get_current_price
        self.call_stops_oco: List[IronCondor.BeStopPrice] = []
        self.put_stops_oco: List[IronCondor.BeStopPrice] = []
        self.be_short_call_stop = IronCondor.BeStopPrice(short_call, 0, long_call, 0, 0, 0)  # Initialize these attributes
        self.be_short_put_stop = IronCondor.BeStopPrice(short_put, 0, long_put, 0, 0, 0)

    def __eq__(self, other):
        return (
            isinstance(other, IronCondor) and
            self.short_call == other.short_call and
            self.long_call == other.long_call and
            self.short_put == other.short_put and
            self.long_put == other.long_put and
            self.entry_time == other.entry_time
        )

    def __hash__(self):
        return hash((
            self.quantity, self.short_call, self.long_call, self.short_put, self.long_put, self.entry_time
        ))

    def get_log_messages(self) -> List[str]:
        basic = f"{self.entry_time.date()} {self.entry_time.time()} Iron Condor, quantity: {self.quantity} short_call: {self.short_call.strike}, long_call: {self.long_call.strike}, short_put: {self.short_put.strike}, long_put: {self.long_put.strike}"
        fill_price = f"Fill Price: short_call {self.be_short_call_stop.short_leg_fill_price}, long_call {self.be_short_call_stop.long_leg_fill_price}, short_put: {self.be_short_put_stop.short_leg_fill_price}, long_put: {self.be_short_put_stop.long_leg_fill_price}"
        stop_count = int(self.be_short_call_stop.is_stopped_out()) + \
            int(self.be_short_put_stop.is_stopped_out())
        status_map = {
            0: "**No Stop**",
            1: "!Single Stop!",
            2: "!!Double Stop!!"
        }
        return [
            basic,
            fill_price,
            status_map[stop_count],
            f"IC realized P/L: {(self.be_short_call_stop.realized_pl() + self.be_short_put_stop.realized_pl()):+.2f}"
        ] + self.be_short_call_stop.debug_messages() + self.be_short_put_stop.debug_messages()

    def limit_mid_price(self, contract: OptionContract) -> float:
        return round_to_nearest_0_05((contract.ask_price + contract.bid_price) / 2)

    def call_premium_est(self) -> float:
        return self.short_call.last_price - self.long_call.last_price

    def put_premium_est(self) -> float:
        return self.short_put.last_price - self.long_put.last_price

    def get_open_limit_legs(self) -> List[Leg]:
        return [
            Leg.create(self.short_call.symbol, -1,
                       round_to_nearest_0_05(self.short_call.bid_price)),
            Leg.create(self.long_call.symbol, 1,
                       round_to_nearest_0_05(self.long_call.ask_price)),
            Leg.create(self.short_put.symbol, -1,
                       round_to_nearest_0_05(self.short_put.bid_price)),
            Leg.create(self.long_put.symbol, 1,
                       round_to_nearest_0_05(self.long_put.ask_price))
        ]

    def get_open_market_legs(self) -> List[Leg]:
        return [
            Leg.create(self.short_call.symbol, -1),
            Leg.create(self.long_call.symbol, 1),
            Leg.create(self.short_put.symbol, -1),
            Leg.create(self.long_put.symbol, 1)
        ]

    def on_ic_filled(self, short_call_fill_price: float, long_call_fill_price: float, short_put_fill_price: float, long_put_fill_price: float):
        call_premium = short_call_fill_price - long_call_fill_price

Sources: Long Iron Condor - QuantConnect.com, Short Iron Condor - QuantConnect.com, Iron Condor Strategy Algorithm, Index Option Iron Condor Algorithm, Automating the Wheel Strategy