Orders filled at much higher price than expected (stock price doesn't go this high)

As per suggesting in discord, I'm attaching some code to make it easier to help debug. Note that I have removed some sensitive portions related to selecting stocks each day and conditions for entering/exiting positions, but I'm fairly sure those aren't contributing to the issue I'm seeing (the stock selection is certainly irrelevant, and the take-profit and stop-loss conditions are fairly innocuous signals that typically trigger within 10-30m after the initial short). 

Again, thanks in advance for any help here!

from AlgorithmImports import *


class StrategyRunner:
    """
    core strategy applied to single consolidated stock
    """
    def __init__(
        self,
        algorithm,       # QCAlgorithm instance
        symbol,          # symbol to trade
        trade_amt=2_500, # fixed dollar amount per trade
        mins=5,          # bars will be consolidated to this many minutes
    ):
        self.algorithm = algorithm
        self.symbol = symbol
        self.trade_amt = trade_amt
        
        self.consolidator = TradeBarConsolidator(timedelta(minutes=mins))
        self.consolidator.DataConsolidated += self.OnDataConsolidated
        algorithm.SubscriptionManager.AddConsolidator(symbol, self.consolidator)

    def OnDataConsolidated(self, sender, tradebar):
        # ENTRY SIGNAL
        if "<CONDITION>":
            cash = min(self.algorithm.Portfolio.Cash, self.trade_amt)
            quantity = -int(cash / tradebar.Close)
            if quantity == 0:
                self.algorithm.Debug(f"Can't trade right now: {self.symbol}, cash={cash}, close={tradebar.Close}")
                return 
            self.algorithm.Debug(
                f"Enter Short Position ({tradebar.EndTime}): {self.symbol} | "
                f"{quantity} shares @ ${tradebar.Close}"
            )
            self.trade_price = tradebar.Close
            self.short_time = tradebar.EndTime
            self.quantity = quantity
            self.algorithm.MarketOrder(tradebar.Symbol, quantity)

        # STOP LOSS
        elif "<STOP LOSS CONDITION>":
            loss = self.quantity * (tradebar.Close - self.trade_price)
            self.algorithm.Debug(
                f"Stop Loss ({tradebar.EndTime}): {self.symbol} | "
                f"price=${tradebar.Close}, loss=${loss}"
            )
            self.algorithm.Liquidate(tradebar.Symbol)
            self.algorithm.stocks_to_trade_today.pop(tradebar.Symbol).destroy()

        # TAKE PROFIT
        elif "<TAKE PROFIT CONDITION>":
            gain = self.quantity * (self.trade_price - tradebar.Close)
            self.algorithm.Debug(
                f"TAKE PROFIT ({tradebar.EndTime}): {self.symbol} | "
                f"price=${tradebar.Close}, gain=${gain}"
            )
            self.algorithm.Liquidate(tradebar.Symbol)
            self.algorithm.stocks_to_trade_today.pop(tradebar.Symbol).destroy()
    
    def destroy(self):
        self.algorithm.SubscriptionManager.RemoveConsolidator(self.symbol, self.consolidator)


class MyShortStrat(QCAlgorithm):
    def Initialize(self):
        self.start_time = '2022-01-01'
        self.end_time = '2022-12-30'
        self.SetStartDate(*map(int, self.start_time.split('-')))
        self.SetEndDate(*map(int, self.end_time.split('-')))

        self.SetCash(100_000)

        self.UniverseSettings.Resolution = Resolution.Minute
        self.AddUniverse(self.CoarseSelectionFunction, self.FineFundamentalFunction)
        # NOTE raw price, comment this line to use adjusted price
        self.UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw

        # close out any open positions right before market close
        # NOTE only trading US, use SPY to set schedule; carful if using non-US too
        self.n_min_before_market_close = 5
        self.paradigm_stock = "SPY"
        self.AddEquity(self.paradigm_stock)
        self.Schedule.On(
            self.DateRules.EveryDay(self.paradigm_stock),
            self.TimeRules.BeforeMarketClose(
                self.paradigm_stock, self.n_min_before_market_close
            ),
            self.CloseOut,
        )

        # coarse filters
        self.volume_thresh = 300_000
        self.price_thresh = 2.0
        self.dollar_vol_thresh = 10_000_000

        # fine filters
        self.public_thresh = 0  # 180
        self.market_cap = 0     # 5e8
        self.countries = {"USA"}
        self.exchanges = {"NYS", "NAS", "ASE"} # NYSE, NASDAQ, AMEX

        # in universe
        self.active_stocks = set()
        # to be traded today
        self.stocks_to_trade_today = []

    def CoarseSelectionFunction(self, coarse):        
        coarse_stocks = [
            x.Symbol for x in coarse if
            x.HasFundamentalData
            # use > if doing > 0.
            and x.Volume >= self.volume_thresh
            # or Value? unclear when this is taken, closing?
            and x.Price >= self.price_thresh
            and x.DollarVolume >= self.dollar_vol_thresh
        ]
        self.Debug(f"CoarseFundamental({self.UtcTime}): {len(coarse_stocks)} selected.")
        return coarse_stocks

    def FineFundamentalFunction(self, fine):
        fine_stocks = [
            x.Symbol for x in fine if 
            x.CompanyReference.CountryId in self.countries
            and x.CompanyReference.PrimaryExchangeID in self.exchanges
            and (self.Time - x.SecurityReference.IPODate).days > self.public_thresh
            and x.MarketCap > self.market_cap
        ]
        self.Debug(f"FineFundamental({self.UtcTime}): {len(fine_stocks)} selected.")
        return fine_stocks

    def CloseOut(self):
        # cancel any open orders
        openOrders = self.Transactions.GetOpenOrders()
        if len(openOrders) > 0:
            for op_ord in openOrders:
                self.Transactions.CancelOrder(op_ord.Id)
        # liquidate any open positions
        self.Liquidate()
        # reset internals
        if self.stocks_to_trade_today:
            for v in self.stocks_to_trade_today.values():
                v.destroy()
        self.stocks_to_trade_today = {}

    # this event fires whenever we have changes to our universe
    # XXX should be nightly! verify
    def OnSecuritiesChanged(self, changes):
        self.Debug(f"{self.UtcTime}: Calling onSecChange")

        # liquidate securities that fell out of our universe
        for security in changes.RemovedSecurities:
            self.Transactions.CancelOpenOrders(security.Symbol)
            if security.Invested:
                self.Liquidate(security.Symbol)
            if security.Symbol in self.stocks_to_trade_today:
                self.stocks_to_trade_today.pop(security.Symbol).destroy()
            self.active_stocks.remove(security.Symbol)

        for security in changes.AddedSecurities:
            self.active_stocks.add(security.Symbol)
        
        # NOTE this stock is only for scheduling events
        if self.paradigm_stock in self.active_stocks:
            self.active_stocks.remove(self.paradigm_stock)

        # XXX further refinement of universe according to strategy-specific conditions
        for symbol in self.active_stocks:
            if "<SOME CONDITION>":
                self.stocks_to_trade_today[symbol] = StrategyRunner(self, symbol)
                self.Debug(f"Stock Selected ({self.UtcTime}): {symbol}")