
<p class="has-drop-cap wp-block-paragraph">1Sedan Christian Lauritz Müller bortgång 1927 har hans minne hedrats med landets äldsta storlopp för äldre hästar. Årets upplaga av C.L. Müllers Memorial med 400.000 kronor till vinnaren håller god klass och Kalmaramatören Elisabeth Almhedens sagohäst <strong>A Fair Day</strong> (e. Maharajah) är tillbaka i större sammanhang efter att ha jobbat hem tre raka segrar på hemmabanan.</p>



<p class="wp-block-paragraph">– Läget blev perfekt och det blir full gas från start, för han biter ifrån sig bra i ledningen. Och skulle jag hitta dit ser det mycket intressant ut, även om han möter en del bra hästar. Men ”Affe” är också riktigt bra. – Nu blir det barfota runt om igen och det är ett plus. Annars går han med öppet huvudlag samt fast huva med bomull, säger Oscar Ginman i Sulkysports fredagsintervju.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/fokus/v75-ginman-optimistisk-kanns-for-jakla-fin/" target="_blank" rel="noreferrer noopener">Läs hela fredagsintervjun om och med Oscar Ginman här.</a></p>



<p class="wp-block-paragraph">Löpningsrekordet har <strong>On Track Piraten</strong> från 2016, men historia skrev även <strong>Delicious</strong> året före. Då satte stoet världsrekord för äldre ston över lång distans med bilstart på tusenmetersbana när hon segrade på 1.12,1a/2.640 meter. Det var tredje starten i rad (!) som Delicious travade snabbare än något annat sto i världen gjort tidigare. I augusti skrev hon historia över kort distans i Bollnäs med 1.08,6a och över medeldistans på Bergsåker 1.10,0a. Världsrekordtrippeln fastställdes alltså i oktober i Müllers på Jägersro.</p>



<h2 class="wp-block-heading">Snabbaste vinnarna av Müllers</h2>



<p class="wp-block-paragraph"><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2016 <strong>On Track Piraten</strong> (e. Kool du Caux) – Johnny Takter (Hans R Strömberg) – 1.11,7a</li>



<li>2015 <strong>Delicious</strong> (e. Cantab Hall) – Örjan Kihlström (Daniel Redén) – 1.12,1a</li>



<li>2019 <strong>Velvet Gio</strong> (e. Nal Ab Sheba) – Ulf Ohlsson (Magnus Dahlén) – 1.12,3a</li>



<li>2020 <strong>Cyber Lane</strong> (e. Raja Mirchi) – Johan Untersteiner – 1.12,3a</li>



<li>2023 <strong>Admiral As</strong> (e. Ready Cash) – Örjan Kihlström (Daniel Redén) – 1.12,5a</li>



<li>2018 <strong>Cyber Lane</strong> (e. Raja Mirchi) – Johan Untersteiner – 1.12,7a</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/07/6dappermal-617x333.jpg" alt="" class="wp-image-605094"/><figcaption class="wp-element-caption">D&#8217;Apper och Magnus A Djuse vann ett försök till Sprintermästaren i juli. Nu är det dags för seger på V75. Foto Lars B Persson</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Vinna eller försvinna. Det har varit toppstammade, fyraårige jänkaren <strong>D’Appers</strong> (e. Walner-D’One) prestationer sedan han kom till Sverige i slutet av förra året. Åtta starter, tre segrar, fyra galopper och ”nolla” visar resultaten. Av segrarna kom den ena i Sprintermästarförsök och den senaste efter en rykande spurt i Fyraåringsstjärnan i Gävle.</p>



<p class="wp-block-paragraph">Nu plockar Daniel Redén ut hästen – med ny galopp i bagaget – i bronsdivisionsförsök från sjundespår bakom bilen över sprinterdistans.<br>– Han galopperade direkt senast, vingen slog honom i huvudet och han är lite känslig så det blev galopp. Det är en väldigt kapabel häst. Jag tycker att han har visat sig vara bäst då han får gå i ryggar så får han bara rätt lopp blir det spännande. Han tränar bra och finns inget att klaga på där, säger Daniel Redén till Stall Zets hemsida.</p>



<p class="wp-block-paragraph">Sulkysports tipsexpert tror hårt på Redéns fyraåring:<br><em>”Jägersro bjuder på en småknepig V75-omgång där jag förlitar mig på ett singelstreck i jakten på sju rätt. Den som får förtroendet är vindsnabbe D’Apper i V75-5. Han gjorde bort sig i finalen i Sprintermästaren i somras, men visade sin höga kapacitet då han vann Fyraåringsstjärnan i Gävle nyligen efter en mäktig spurt. Repris nu, tack!”, </em>skriver Magnus Blom.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-dapper-speedar-forbi-konkurrenterna/" target="_blank" rel="noreferrer noopener">––> Här är hela tipsgenomgången till V75 på Jägersro.</a></p>



<p class="wp-block-paragraph">Missa inte andelsspelen hos vår samarbetspartner Travnet på Högkvarteret.<br><a href="https://www.atg.se/hogkvarteret/V75_2024-10-26_7_5" target="_blank" rel="noreferrer noopener">Här finns Travnets andelar.</a></p>



<p class="wp-block-paragraph">Jägersros stortävlingar ramas in av dubbla breddloppsomgångar på svensk mark. Boden (start 11.10) är först ut och Färjestad (start 18.30) avrundar lördagen.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/10/241026.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">3Åtta starter, åtta segrar och triumf i både Norskt Travkriterium och Biris Uppfödningslopp på meritlistan. Att treårige, norske kallblodet <strong>Gigant Tider</strong> (e. Norheim Svenn) inlett sin tävlingskarriär på bästa sätt hos Kjetil Djöseland råder inga tvivel om.</p>



<p class="wp-block-paragraph">På Sörlandet ikväll – norrmännen drar igång efter den svenska V75-omgången på Jägersro – väntar DNT:s Höstfinaler för treåringar av båda raserna med 100.000 kronor i förstapris i varje. Gigant Tider blir förstås megafavorit i loppet som är en spårtrappa med åtta hästar.<br>Bland motståndarna märks Öystein Tjomslands-tränade <strong>Tangen Martin</strong> (e. Bork Odin), som fightats i alla storlopp hittills. Han slutade trea i svenska Kriteriet, tvåa i norska Kriteriet och trea i Biris Uppfödningslopp.</p>



<p class="wp-block-paragraph">På varmblodssidan sticker två hästar ut lite extra. Tjomslands <strong>Felix Halbak</strong> (e. Orlando Vici) vann Prinsesse Märthe Louises Pokallopp i somras och slutade trea i norska Kriteriet. Han är vinstrikast i norska kullen så här långt.<br>Nu ställs han mot Geir Vegard Gundersens sto <strong>Skylight</strong> (e. Readly Express), som efter sex raka segrar åkte på karriärens första förlust i finalen av Stokriteriet på Bjerke.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/10/st20241026baneprogram.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Sörlandets tävlingar.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/daiquirihanover19102024lisa-617x346.jpg" alt="" class="wp-image-649571"/><figcaption class="wp-element-caption">Daiquiri Hanover och Åke Svanstedt tar seger 7.000 på Meadowlands i lördags. Foto: Lisa Photo</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4I natt fortsätter finalerna i Breeders Crown ($600.000) för treåringarna på Meadowlands. Åke Svanstedt har det rejält förspänt i hingstarnas och valackernas final med fyra hästar.</p>



<p class="wp-block-paragraph">Åke väljer själv att köra <strong>Daiquri Hanover</strong> (e. Bar Hopping), som han vann sin 7.000:e seger med i BC-försöket. Dexter Dunn tar hand om <strong>Amazing Catch</strong> (e. Walner) och svenskfödde <strong>Tony Adams</strong> (e. Muscle Hill) körs av James MacDonald. Kvalat in till finalen har också Marcus Melanders <strong>Security Protected</strong> (e. Father Patrick).</p>



<p class="wp-block-paragraph">Av årets finalister startade fyra i fjolårets final: T C I (tvåa), Security Protected (trea), Private Access (fyra) och Greenspan (femma). </p>



<p class="wp-block-paragraph"><strong>Breeders Crown ($600.000), treåriga hingstar/valacker</strong></p>



<ol class="wp-block-list">
<li>Private Access (e. Muscle Hill) – Louis-Philippe Roy/Luc Blais</li>



<li>Daiquiri Hanover (e. Bar Hopping) – Åke Svanstedt</li>



<li>Amazing Catch (e. Walner) – Dexter Dunn/Åke Svanstedt </li>



<li>Highland Kismet (e. Father Patrick) – Tim Tetrick/Mark Etsell</li>



<li>Security Protected (e. Father Patrick) – Scott Zeron/Marcus Melander</li>



<li>T C I (e. Cantab Hall) – David Miller/Ron Burke</li>



<li>Greenspan (e. Greenshoe) – Todd McCarthy/Jim Campbell</li>



<li>Sig Sauer (e. Muscle Hill) – Andrew McCarthy/Noel Daley</li>



<li>Secret Agent Man (e. Chapter Seven) – Andy Miller/Julie Miller</li>



<li>Tony Adams (e. Muscle Hill) – James MacDonald/Åke Svanstedt </li>
</ol>



<p class="wp-block-paragraph">Tre svensktränade ston gör också upp om en Breeders Crown-titel. Förra året vann Åke Svanstedt bakom <strong>Warrawee Michelle</strong> (e. Walner) och hon finns också med i årets final. Där startar också Marcus Melander <strong>Date Night Hanover</strong> (e. Walner) och Lucas Wallin <strong>Soiree Hanover</strong> (e. Walner). </p>



<p class="wp-block-paragraph">Fem av årets finalister kvalade också in till finalen förra året. Förutom vinnaren Warrawee Michelle handlade det om Soiree Hanover (tvåa), Drawn Impression (fyra), Sugar Instead (nia) och Date Night Hanover (tia). </p>



<p class="wp-block-paragraph"><strong>Breeders Crown ($600.000), treåriga ston.</strong></p>



<ol class="wp-block-list">
<li>Willy’s Home Run (e. Archangel) – James MacDonald/Robert Fellows</li>



<li>Drawn Impression (e. Muscle Hill) – Louis-Phillippe Roy/Luc Blais</li>



<li>Sugar Instead (e. Volstead) – Brett Miller/Virgil Morgan Jr.</li>



<li>Soiree Hanover (e. Walner) – Tim Tetrick/Lucas Wallin</li>



<li>Allegiant (e. Tactical Landing) – Scott Zeron/Linda Toscano</li>



<li>Elista Hanover (e. International Moni) – David Miller/Annie Stoebe</li>



<li>Date Night Hanover (e. Chapter Seven) – Dexter Dunn/Marcus Melander</li>



<li>R Melina (e. Chapter Seven) – Todd McCarthy/John Butenschoen</li>



<li>Sadbirdstillsing (e. Chapter Seven) – Yannick Gingras/Tony Alagna</li>



<li>Warrawee Michelle (e. Walner) – Åke Svanstedt</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">5För Åke Svanstedt-tränade duon <strong>Call Me Goo</strong> (e. Googoo Gaagaa) och <strong>Nelson Brite Eagle</strong> (e. Bold Eagle) har ägarna till respektive häst betalat in 48.000 dollar vardera för att starta i finalen i Breeders Crown ($496.000) för äldre ston. Ytterligare en svensktränad deltagare finns med i loppet, Anette Lorentzons <strong>Pioneer Ås</strong> (e. Devious Man). </p>



<p class="wp-block-paragraph">Det behövdes inga försök för de äldre stona och inte heller i den öppna klassen i Breeders Crown ($600.000) där sex av elva finalister tränas av svenskar. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/09/periculum23182024nicholasbarnsdalephoto-617x411.jpg" alt="" class="wp-image-628650"/><figcaption class="wp-element-caption">Periculum vid vinst i Maple Leaf Trot. Foto Nicholas Barnsdale Photo</figcaption></figure>



<p class="wp-block-paragraph"><strong>Breeders Crown ($600.000), äldre travare.</strong></p>



<ol class="wp-block-list">
<li>Ari Ferrari J (e. Walner) – Jason Bartlett/Tony Alagna</li>



<li>Up Your Deo (e. Walner) – Åke Svanstedt</li>



<li>Asteroid (e. Creatine) – Tim Tetrick/Jeff Cullipher</li>



<li>It’s Academic (e. Uncle Peter) – David Miller/Ron Burke</li>



<li>Winner’s Bet (e. Walner) – Dexter Dunn/Nancy Takter</li>



<li>Hillexotic (e. Muscle Hill) – Austin Hanners/Todd Luther</li>



<li>Periculum (e. Muscle Hill) – Scott Zeron/Marcus Melander</li>



<li>Hasty Bid (e. My MVP) – James MacDonald/Nancy Takter</li>



<li>Bestfriend Volo (e. Walner) – Yannick Gingras/Nancy Takter</li>



<li>Logan Park (e. Archangel) – Douglas McNair/Robert Fellows</li>



<li>Oh Well (e. Muscle Hill) – Todd McCarthy/Marcus Melander</li>
</ol>



<p class="wp-block-paragraph"><strong>Breeders Crown ($496.000), äldre ston.</strong></p>



<ol class="wp-block-list">
<li>Swans Eye (e. Swan For All) – Braxten Boyd/Vincent Campolong</li>



<li>Warrawee Xenia (e. Walner) – Jason Bartlett/Mark Steacy</li>



<li>Call Me Goo (e. Googoo Gaagaa) – Åke Svanstedt</li>



<li>Refined (e. Uncle Peter) – Douglas McNair/Virgil Morgan Jr.</li>



<li>M-M’s Dream (e. Swan For All) – David Miller/Ron Burke</li>



<li>Baroness Hill (e. Kadabra) – Todd McCarthy/Virgil Morgan Jr.</li>



<li>Tactical Mounds (e. Tactical Landing) – Scott Zeron/Megan Scran</li>



<li>Nelson Brite Eagle (e. Bold Eagle) – Dexter Dunn/Åke Svanstedt</li>



<li>Pioneer Ås (e. Devious Man) – Tim Tetrick/Anette Lorentzon</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">6Ett av Finlands största treåringslopp är Kymenlaakso-Ajo (€90.000) i Kouvola, där vinnaren plockar hem 36.000 euro. Det som skiljer många andra större lopp är att loppet både avgörs i voltstart med två volter och att hästarna på startfållan fått tjäna max 7.000 euro inför försöken.</p>



<p class="wp-block-paragraph">Fem försök kördes i Kouvola för nio dagar sedan och vanns av <strong>Knight Rider Hoss</strong> (e. Scarlet Knight) på 1.15,6/2.100 meter från startfållan, medan trion <strong>Goodbrother</strong> (e. Knows Nothing), 1.14,4/2.120 meter, <strong>Neymar Web</strong> (e. Like A Prayer), 1.14,8, och Kriterietvåan <strong>Arctic Emerald</strong> (e. Express Duo), 1.15,6.<br>Den femte försöksvinnaren – och årets finske Kriterievinnare – <strong>Lil Runner</strong> (e. So Perfect), 1.15,1, är struken ur finalen.</p>



<h2 class="wp-block-heading">Startlista Kymenlaakso-Ajo (€90.000)</h2>



<p class="wp-block-paragraph">2.100 meter voltstart, förstapris 36.000 euro<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li>Knight Rider Hoss (e. Scarlet Knight) – Olli Koivunen</li>



<li>Callela Callmeboss (e. Maharajah) – Hannu Torvinen</li>



<li>Bushmills (e. Tobin Kronos) – Jani Ruotsalainen</li>



<li>Ranger Ale (e. Googoo Gaagaa) – Ari Moilanen</li>



<li>Mansester (e. Maharajah) – Esa Holopainen <br><em>2.120 meter:</em></li>



<li>Goodbrother (e. Knows Nothing) – Jarmo Saarela</li>



<li>Neymar Web (e. Like A Prayer) – Santtu Raitala</li>



<li>Lil Runner (e. So Perfect) – <em>struken</em></li>



<li>All Out You (e. All Laid Out) – Tommi Kylliäinen</li>



<li>Nacho Web (e. Like A Prayer) – Henri Bollström</li>



<li>Ze On Alma (e. Harper Blue Chip) – Juha Utala</li>



<li>Arctic Emerald (e. Express Duo) – Pekka Korpi</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">7En fyraårig lillebror till Muscle Hill! Det är en av 27 starthästar som bjuds ut på Traveras internetauktion ikväll. USA-födde <strong>All Star Yankee</strong> (e. My Mvp) har långt till broderns meriter, men startar i eftermiddag i Johan Jacobssons Minne inom Jägersros V75-omgång.<br>I övrigt: Storloppsmeriter som unghäst har Oaksfinalisten, femåriga <strong>Nycora</strong> (e. Nuncio), som tjänat nästan 850.000 kronor.<br>Tvååriga stoet <strong>Ultra Tile</strong> (e. Maharajah) har vunnit Yearling Sales auktionslopp i år, medan fyraårige <strong>Make It Q.L.</strong> (e. Make It Happen) inlett tävlingskarriären med tre segrar på elva starter.</p>



<p class="wp-block-paragraph">En betäckning med Greenshoe, nio fölston, tre ettåringar (två med Power och en med Donato Hanover som fäder) och en tvååring (e. Cash Gamble) finns också i kvällens digitala katalog. Av fölstona är bland annat två dräktiga med Father Patrick och lika många med San Moteur.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som säljs och följa budgivningen under kvällen.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
”Det blir full gas från start”
On Track Piratens rekord i fara? Vinnare i Sprintermästarförsök i bronsdivisionen. Obesegrat jätteämne jagar sexsiffrig prischeck. Alla svenskar i nattens Breeders Crown-finaler på Meadowlands. Kriterievinnare missar storloppsfinal.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
