
<p class="has-drop-cap">1Han mäter blott 146 centimeter över manken – ”han än mindre än Delicious”, har tränaren Daniel Redén sagt – men har ett hjärta av guld. Fyraårige jänkaren <strong>Keep Asking</strong> (e. Chapter Seven) ropades in för 160.000 dollar på Harrisburgs mixedauktion förra hösten och anlände till Sverige med över sex miljoner kronor på kontot.</p>



<p>Sex starter, fyra segrar och en dryg miljon kronor senare är han storfavoriten i eftermiddagens störstalopp på Bjerke (första start 14.45): Axel Jensens Minneslopp. Spår tre och sprinterdistans är förutsättningarna när Örjan Kihlström sitter i sulkyn.<br>– Han har inte startat på ett tag, men känns jättefin. Han gick ett tuffare jobb i måndags och jag räknar med att han ska vara bra. Han är lätt och fin i kroppen och bör inte ha några problem med ett litet uppehåll, säger Daniel Redén till Stall Zets hemsida.</p>



<p>Axel Jensens Minneslopp för fyraåringar har varit en senhösthöjdare på Bjerke för fyraåriga varmblod i många år. Sedan 1986 har grupp II-loppet avgjorts enligt nuvarande format: sprinterdistans, startbil och fyraåriga varmblod.</p>



<p><strong>Alla vinnare som travat under 1.12</strong><br><em>Segertid – År – Vinnare (far) – Kusk (tränare)</em></p>



<ul class="wp-block-list">
<li>1.10,4a – 2015 – <strong>Buzz Mearas</strong> (e. Dream Vacation) – Adrian Kolgjini (Lutfi Kolgjini)</li>



<li>1.10,4a – 2023 – <strong>Demon</strong> (e. Royal Blessed) – Carl Johan Jepson (Gennaro Casillo)</li>



<li>1.10,7a – 2024 – <strong>Charron</strong> (e. Code Bon) – Magnus Teien Gundersen (Geir Vegard Gundersen)</li>



<li>1.11,0a – 2017 – <strong>Ferrari B.R.</strong> (e. Muscles Yankee) – Per Oleg Midtfjeld</li>



<li>1.11,2a – 2022 – <strong>Type A.</strong> (e. Southwind Frank) – Magnus Teien Gundersen (Frode Hamre)</li>



<li>1.11,5a – 2016 – <strong>Twister Bi</strong> (e.Varenne) – Christoffer Eriksson (Jerry Riordan)</li>



<li>1.11,7a – 2014 – <strong>Tumble Dust</strong> (e. Crazed) – Björn Goop (Tomas Malmqvist)</li>



<li>1.11,8a – 2018 – <strong>Vainqueur R.P.</strong> (e. Infinitif) – Ulf Ohlsson (Frode Hamre)</li>



<li>1.11,8a – 2021 – <strong>Fire n’Fury</strong> (e. Explosive Matter) – Mats E Djuse (Stefan Melander)</li>



<li>1.11,9a – 2013 – <strong>Stelton</strong> (e. Dream Vacation) – Jeppe Juel</li>
</ul>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/10/18v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar på Bjerke.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/mariatornqvist2025-617x333.jpg" alt="" class="wp-image-777381"/><figcaption class="wp-element-caption">Maria Törnqvist. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">2Tävlingarna må avgöras i Norge, men det är övervikt svensktränade hästar på V75-kupongen.  Hela 44 av 82 anmälda hästar är tränade i Sverige. Det var mycket svenskt i startlistorna förra året också även om dominansen inte var lika stor som nu. Då blev det 4-3 till Sverige. </p>



<p>Annars är det stort fokus på att en 32-årig megasuccé går i graven. ATG lägger ner V75-spelet för att lägga till ett lopp och satsa på V85 från och med nästa lördag på Jägersro.<br>Sulkysports spelpartner Simsalabims expert Fredrik Persson har synat ”sista natten med V75” och hämtar båda spikarna från svenska stall.</p>



<p>Ovan nämnde Keep Asking är den ene – Maria Törnqvist-tränade <strong>Fawaz Mil</strong> (e. Gu d’Heripre) den andre. Fawaz Mil har gjort en start på Bjerke tidigare. På Oslo Grand Prix-dagen ledde han länge stayerloppet, men fick se sig passerad av <strong>Immortal Doc</strong> (e. Brillantissime) som tvåa.</p>



<p>Då handlade det om drygt tre kilometer, men dagens uppgift är bara halva distansen: 1.609 meter.<br>– Han har varit en väldigt positiv överraskning under året. Han är väldigt allround och klarar alla distanser. Över 1.600 meter är han för övrigt obesegrad i tre starter. Nu är det ett lite chansartat utgångsläge och dessutom kan jag inte motståndet så bra, men jag vet att vi har en bra häst för klassen och med bara minsta klaff så bör han kunna vara med i striden, säger Maria Törnqvist på stallets hemsida.</p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-blagula-spikar-i-norge/" target="_blank" rel="noreferrer noopener">––> Här är hela tipsgenomgången med viktiga punkter, spikar och favoriter i fara på V75 idag.</a></p>



<p>Vill Du spela V75 tillammans med Sulkysports expert?</p>



<p><a href="https://www.atg.se/simsalabim/spel/296591_V75_2025-10-18_78_5" target="_blank" rel="noreferrer noopener">Här kan Du köpa en andel i systemförslaget för 150 kr/andel</a></p>



<p>På svensk mark då? Ja, Åby (första start start 11.10) är ensam på banan med en omgång breddlopp.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/10/18v4.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Åbys tävlingar.</a></p>



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



<p class="has-drop-cap">3Igår klev Björn Goop in i 3.000-klubben för tränare me svensk licens. Därmed blev han elfte svenske tränare att klara den bedriften. Segerhästen var treårige debutanten <strong>Lindy&#8217;sleadingman</strong> (e. Walner), som slog till med Goop i vagnen på hemmabanan Färjestad.</p>



<p>Stig H Johansson toppar svenska tränarligan med 8.206 segrar, drygt 500 fler än Björns appa Olle som är tvåa. Av tränarna som är aktiva i Sverige är Robert Bergh bäst med 5.390 segrar på tredjeplatsen. Han passerade nyligen tidigare trean Åke Svanstet, vars segrar som amerikansk tränare inte räknas in i denna statistik från Nordiska Travmuséet.</p>



<p><strong>Sveriges segerrikaste tränare</strong>:</p>



<ol class="wp-block-list">
<li>Stig H Johansson – 8.206 segrar</li>



<li>Olle Goop – 7.696 segrar</li>



<li>Åke Svanstedt – 5.384 segrar</li>



<li>Robert Bergh – 5.390 segrar</li>



<li>Timo Nurmos – 3.872 segrar</li>



<li>Peter Untersteiner – 3.677 segrar</li>



<li>Jan-Olov Persson – 3.308 segrar</li>



<li>Jim Frick – 3.187 segrar</li>



<li>Kari Lähdekorpi – 3.048 segrar</li>



<li>Lutfi Kolgjini – 3.023 segrar</li>



<li>Björn Goop – 3.000 segrar</li>
</ol>



<p><em>Statistiken gäller segrar med svensk tränarlicens.</em><br><strong>Källa:</strong> Nordiska Travmuséet/Tusenklubben</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/3daimbrodda-617x333.jpg" alt="" class="wp-image-655173"/><figcaption class="wp-element-caption">Daim Brodda och Eirik Höitomt. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">4En häst som saknas på Bjerke idag är Norge bästa sto – och en av landets allra bästa hästar överhuvudtaget. Svenskfödda Daim Brodda (e. Readly Express) skulle ha varit med i Svenskt Mästerskap på Åby för en månad sedan, men Derbysto- och Breeders Crown-vinnaren i Sverige förra året tvingades strykas på grund av hovböld.</p>



<p>Och det har varit en efterhängsen sådan. <br>– Det har varit bekymmer efteråt. Det brukar gå över snabbt, men har tagit tid för henne och varit komplicerat. Nu har det blivit bättre och hon är precis igång igen, men vi har inga framtidsplaner klara, sade Stian Hallenstvedt i Thor Borgs stall till V65 Direkt. </p>



<p>Daim Brodda har gjort 21 starter (13-1-3) pch sprungit in 6.202.328 kronor. Rekordet 1.10,0ak sattes i somras som trea i Hugo Åbergs Memorial.</p>



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



<p class="has-drop-cap">5S:t Leger i Finland lockar med 36.000 euro till vinnaren och 16 hästar från tre volter över lång distans gör upp om vinster i Björneborg i eftermiddag. Två försök förra veckan plockade fram finalisterna och en av vinnarna var Finlands bästa äldre häst just nu, Elitloppssexan <strong>Massimo Hoist</strong> (e. Muscle Hill).<br>Denne följde upp de starka insatserna på Solvalla med att vinna ”finska mästerskapet” Suur-Hollola-Ajo en dryg månad senare och har vunnit sju av tolv starter 2025.</p>



<p>I S:t Leger har fyraåriga ston 40 meters gottgörelse, medan fyraåriga hingstar/valacker och äldre ston startar 20 meter före de mest meriterade killarna. Det andra försöket skrällvanns av just ett äldre sto, <strong>Dorea Frido</strong> (e. Muscle Hill), som startar från mellanvolten i finalen.</p>



<h2 class="wp-block-heading">Startlista S:t Leger (€79.200)</h2>



<p>2.600 meter voltstart, Björneborg lördag:<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Ginza</strong> (e. Fabulous Wood) – Ilkka Korpi</li>



<li><strong>Daisy Garden</strong> (e. Maharajah) – Tommi Kylliäinen</li>



<li><strong>One Of</strong> (e. Maharajah) – Jukka Torvinen<br>2.620 meter:</li>



<li><strong>Dorea Frido</strong> (e. Muscle Hill) – Tuuka Varis</li>



<li><strong>Icella</strong> (e. Maharajah) – Ari Moilanen</li>



<li><strong>Arctic Emerald</strong> (e. Express Duo) – Janne Korpi</li>



<li><strong>Knight Rider Hoss</strong> (e. Scarlet Knight) – Iikka Nurmonen</li>



<li><strong>Fortunewheelgarden</strong> (e. Trixton) – Tino Keväänranta</li>



<li><strong>Callela Ellen</strong> (e. Love You) – Henri Bollström</li>



<li><strong>Neymar Web</strong> (e. Like A Prayer) – Mika Forss</li>



<li><strong>Christine L.Garden</strong> (e. Maharajah) – Jarmo Saarela</li>



<li><strong>Halley Wania</strong> (e. E L Titan) – Esa Holopainen <br>2.640 meter: </li>



<li><strong>Crepe Match</strong> (e. Creatine) – Olli Koivunen</li>



<li><strong>Main Stage</strong> (e. Prodigious) – Santtu Raitala</li>



<li><strong>Massimo Hoist</strong> (e. Muscle Hill) – Hannu Torvinen</li>



<li><strong>Corazon Combo</strong> (e. Express Duo) – Pekka Korpi</li>
</ol>



<p><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5QXzE4LjEwLjIwMjUucGRm&#038;m=PrS37JUxF8lNeFoWVvQf53QbDY0%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till alla lopp i Björneborg.</a></p>



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



<p class="has-drop-cap">6Försöken till Breeders Crown (C$34.250) fortsätter idag för treåriga ston och äldre travare på Mohawk Raceway. Åtta svensktränade travare ska försöka kvala in till finalen och de fem främsta går vidare från varje försök.</p>



<p><strong>Följande treåriga ston selas ut från blågula tränare: </strong><br><em>Namn (far) – Tränare</em></p>



<ul class="wp-block-list">
<li><strong>Champagne Problems</strong> (e. Tactical Landing) – Nancy Takter</li>



<li><strong>Delaney Hanover</strong> (e. Muscle Hill) – Lucas Wallin</li>



<li><strong>Highlandstarburst</strong> (e. Father Patrick) – Nancy Takter</li>



<li><strong>Kadena</strong> (e. Gimpanzee) – Marcus Melander</li>



<li><strong>Royal Mission</strong> (e. Chapter Seven) – Marcus Melander</li>



<li><strong>Torrisi</strong> (e. Walner) – Nancy Takter</li>



<li><strong>What A Bid Hanover</strong> (e. Muscle Hill) – Åke Svanstedt</li>



<li><strong>Xalapa</strong> (e. Muscle Hill) – Nancy Takter</li>
</ul>



<p>I den öppna klassen – ett försök – för äldre travare ligger också 34.250 kanadensiska dollar i potten och det gäller att vara bland de åtta främsta för att ta sig till final. Två hästar är redan klara för final – Marcus Melanders Periculum (e. Muscle Hill) och Ron Burke-tränade Southwind Coors (e. Walner). </p>



<p><strong>Fyra hästar i kvalen är svensktränade: </strong><br><em>Namn (far) – Tränare</em></p>



<ul class="wp-block-list">
<li><strong>French Wine</strong> (e. Bar Hopping) – Nancy Takter</li>



<li><strong>Get A Wish</strong> (e. Wishing Stone) – Åke Svanstedt</li>



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



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



<p><a href="https://standardbredcanada.ca/racing/entries/data/e1018wbsbsn.dat" target="_blank" rel="noreferrer noopener">Samtliga startlistor till Mohawks tävlingar hittar ni här.</a></p>



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



<p class="has-drop-cap">7Svenskarna ligger rätt lågt på fransk mark idag. Ensam att försvara färgerna är Jarmo Niskanen på Parisbanan Enghien. Hans sto <strong>Kai La Sha</strong> (e. Earl Simon) står bra inne på pengarna i ett femåringslopp för ston med högst 63.000 euro på kontot. Kai La Sha har sprungit in 61.020 euro och inleder från framspår bakom bilen över 2.150 meter tillsammans med Joan Melis Macais.</p>



<p>Ett lopp är öppet för europeiska hästar, ett lärlingslopp med 16.650 euro till vinnaren, och där startar Richard Westerink-tränade <strong>Ziva</strong> (e. Varenne).</p>



<p><a href="https://www.letrot.com/courses/programme/2025-10-18/7502" target="_blank" rel="noreferrer noopener">Här är startlistorna till Enghiens tävlingar.</a></p>
