Start with 9:31

Here is a QuantConnect Python algorithm that implements your requested strategy:

from AlgorithmImports import *

class DigitallGapUpAlgorithm(QCAlgorithm):
    """
    Digitall trading strategy
      1. 09:31:10 ET scan for top-25 gap-up stocks that:
         • open ≥ $0.50
         • pre-market volume (00:00-09:31) > 1 000 000 shares
      2. Intraday (second-resolution):
         • Buy if the day’s high ≥ 130 % of the open
         • Sell if P/L ≥ +35 % or ≤ -35 %
      3. Liquidate a few seconds before the close and reset.
      4. Detailed logging ONLY for SBET on 2021-05-27.
    """

    # --------------------------------------------------------------- #
    #   INITIALISE                                                   #
    # --------------------------------------------------------------- #
    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100_000)

        # Universe: minute data with extended hours so we can query pre-market volume
        self.universe_settings.resolution = Resolution.MINUTE
        self.universe_settings.extended_market_hours = True
        self._max_coarse_count = 1_000          # how many symbols to inspect daily

        # ---- day-specific state containers
        self._coarse_data: list[CoarseFundamental] = []
        self._watchlist: set[Symbol] = set()
        self._open_prices: dict[Symbol, float] = {}
        self._day_highs: dict[Symbol, float] = {}
        self._purchased: set[Symbol] = set()
        self._morning_scan_ran: bool = False

        # ---- universe selection & schedules
        self.add_universe(self._coarse_selection)
        self.schedule.on(self.date_rules.every_day(),
                         self.time_rules.at(9, 31, 10),
                         self._morning_scan)
        self.schedule.on(self.date_rules.every_day(),
                         self.time_rules.at(15, 59, 50),
                         self._prepare_for_close)

    # --------------------------------------------------------------- #
    #   UNIVERSE SELECTION                                            #
    # --------------------------------------------------------------- #
    def _coarse_selection(self, coarse: list[CoarseFundamental]) -> list[Symbol]:
        liquid = [c for c in coarse if c.price >= 0.5]
        liquid.sort(key=lambda c: c.dollar_volume, reverse=True)
        self._coarse_data = liquid[: self._max_coarse_count]
        return [c.symbol for c in self._coarse_data]

    # --------------------------------------------------------------- #
    #   MORNING SCAN                                                  #
    # --------------------------------------------------------------- #
    def _morning_scan(self) -> None:
        if self._morning_scan_ran:
            return
        self._morning_scan_ran = True

        midnight = datetime(self.time.year, self.time.month, self.time.day)
        end_time = self.time              # 09:31:10
        candidates: list[tuple[Symbol, float, float]] = []   # (symbol, gap%, open)

        for cd in self._coarse_data:
            symbol = cd.symbol
            if symbol not in self.securities:
                continue

            open_price = float(self.securities[symbol].open)
            if open_price <= 0:
                continue

            daily_hist = self.history(symbol, 2, Resolution.DAILY)
            if daily_hist.empty or 'close' not in daily_hist.columns:
                continue
            prev_close = float(daily_hist['close'].iloc[-1])
            if prev_close <= 0:
                continue

            gap_pct = (open_price - prev_close) / prev_close

            # aggregate pre-market volume
            m_hist = self.history(symbol, midnight, end_time,
                                  Resolution.MINUTE, extended_market_hours=True)
            pre_volume = int(m_hist['volume'].sum()) if not m_hist.empty else 0

            # filter flags
            passes = open_price >= 0.5 and pre_volume > 1_000_000
            reason = ("Open price < $0.50" if open_price < 0.5
                      else f"Premarket volume {pre_volume:,} ≤ 1,000,000")

            # special detailed SBET logging for 2021-05-27
            if symbol.value == "SBET" and self.time.date() == datetime(2021, 5, 27).date():
                if passes:
                    self.debug("SBET INCLUDED in watchlist on 05/27: passed all filters.")
                else:
                    self.debug(f"SBET EXCLUDED on 05/27: {reason}.")

            if passes:
                candidates.append((symbol, gap_pct, open_price))

        if not candidates:
            self.debug("Morning scan found no qualified candidates.")
            return

        candidates.sort(key=lambda x: x[1], reverse=True)
        selected = candidates[:25]
        self._watchlist = {sym for sym, _, _ in selected}

        # subscribe at second resolution & store open / high trackers
        for sym, _, op in selected:
            self._open_prices[sym] = op
            self._day_highs[sym] = op
            self.add_equity(sym.value, Resolution.SECOND, extended_market_hours=False)

        self.debug(f"Morning scan complete – {len(selected)} symbols added to watchlist.")

    # --------------------------------------------------------------- #
    #   ONDATA — SECOND-RESOLUTION HANDLER                            #
    # --------------------------------------------------------------- #
    def on_data(self, data: Slice) -> None:
        if not self._watchlist:
            return

        to_remove: set[Symbol] = set()

        for symbol in list(self._watchlist):
            if symbol not in data.bars:
                continue
            bar = data.bars[symbol]

            # track intraday high
            self._day_highs[symbol] = max(self._day_highs.get(symbol, 0.0), float(bar.high))

            # ---- Entry: 30 % breakout over open
            if symbol not in self._purchased and symbol in self._open_prices:
                op = self._open_prices[symbol]
                if op > 0 and self._day_highs[symbol] >= op * 1.30:
                    qty = self.calculate_order_quantity(symbol, 0.10)
                    if qty != 0:
                        self.market_order(symbol, qty)
                        self.debug(f"BUY {qty} {symbol} @ {bar.close:.2f} "
                                   f"(>=30 % over open {op:.2f})")
                        self._purchased.add(symbol)

            # ---- Exit: ±35 % unrealised
            holding = self.portfolio[symbol]
            if holding.invested:
                pnl_pct = holding.unrealized_profit_percent
                if pnl_pct >= 0.35 or pnl_pct <= -0.35:
                    self.liquidate(symbol,
                                   f"Exit on {'profit' if pnl_pct > 0 else 'loss'} {pnl_pct:.1%}")
                    to_remove.add(symbol)

        # house-cleaning for symbols no longer tradable today
        for sym in to_remove:
            self._watchlist.discard(sym)
            self._purchased.discard(sym)
            self._open_prices.pop(sym, None)
            self._day_highs.pop(sym, None)

    # --------------------------------------------------------------- #
    #   PRE-CLOSE WRAP-UP                                             #
    # --------------------------------------------------------------- #
    def _prepare_for_close(self) -> None:
        if self.portfolio.invested:
            self.liquidate()
            self.debug("Liquidated all holdings before the market close.")

        # reset daily state
        self._watchlist.clear()
        self._purchased.clear()
        self._open_prices.clear()
        self._day_highs.clear()
        self._morning_scan_ran = False

This code creates a new watchlist every day after 9:31:10 AM ET, filters for the top 25 gap-up US stocks by open price and pre-market volume, scans those every second, buys if the day's high exceeds 30% over open, and auto-sells at 35% gain/loss or at close. It logs exactly why SBET was (or wasn't) included on 5/27. After close, everything is reset for the next day.

Sources: Overnight Anomaly, Head & Shoulders TA Pattern Detection, Momentum And State Of Market Filters, Momentum Effect In Commodities Futures, WallStreetBets - QuantConnect.com