
<p class="has-drop-cap wp-block-paragraph">1På svensk mark – i Anders Svanstedts regi – gjorde <strong>Combat Fighter</strong> (e. From Above) 45 starter (9-11-4) och sprang in 1.575.000 kronor med den delade triumfen i silverdivisionsfinalen på Solvalla i mars förra året som den största segern. Då löpte Combat Fighter dött lopp med Danao Degli Dei (e. Mago d’Amore).</p>



<p class="wp-block-paragraph">Knappt fem månader senare lämnade han Sverige och Svanstedt för finske topptränaren Antti Ojanperäs stall.<br>– Affären var inte direkt enkel, men Kari Lähdekorpi tog hand om jobbet och fick det klart. Jag ser fram emot det. Det blir en andelshäst, sade Antti Ojanperä till MT Hevoset när affären var i hamn.</p>



<p class="wp-block-paragraph">I sitt nya hemland har Combat Fighter gjort succé. Han inledde sju raka segrar och har vunnit elva av 17 lopp i sin nya regi.<br>Han har också testat i tuffa sällskap. Som när han slutade fyra bakom svenska topptrion Mellby Jinx, Betting Pacer och Decision Maker i Finlandia-Ajo på Vermo i maj och besegrade hästar som Double Deceiver och Clarissa.</p>



<p class="wp-block-paragraph">Ikväll gör han andra starten i sitt gamla hemland när Combat Fighter är storfavorit i V86-inledningen i Boden (första start 18.27). Förra besöket – i oktober förra året – slutade med seger i silverdivisionsförsök i Boden.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Kvällens tre största lopp körs på Solvalla (första start 18.15) när det är tre finaler i Solvallaserien med 150.000 kronor till vinnaren i varje. Det handlar om tredje meetinget i Solvallas onsdagsserie, där hästarna måste ha deltagit i minst ett försök för att få vara med i finalerna.</p>



<p class="wp-block-paragraph">Firma Timo Nurmos/Magnus A Djuse står bakom favoriterna i två av avdelningarna, däribland högkapable femåringen <strong>Barn Ready</strong> (e. Ready Cash), som startade som jättefavorit i klass II-finalen på Solvallas superlördag. Då fick han se sig slagen av <strong>Steady Express</strong> (e. Readly Express), som var formidabel efter tidig ledning.<br>Chansen till en annan finalseger kommer alltså snabbt när Barn Ready startar i Solvallaseriens högsta klass – 720 – och där får han göra jobbet från bakspår.</p>



<p class="wp-block-paragraph">Desto bättre uthgångsläge har duons andra tunga streckfavirit, stoet <strong>Diamond Jackie</strong> (e. Djali Boko) i lägsta klassen. Diamond Jackie har vunnit hälften av livets tio starter.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/10/22v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till kvällens tävlingar på Solvalla och i Boden.</a></p>



<p class="wp-block-paragraph"><em>Hos Sulkysports spelpartner Simsalabim finns andelar till kvällens V86-omgång.</em><br>Hitta din andel här!</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/2025/06/johanuntersteiner-617x333.jpg" alt="" class="wp-image-732826"/><figcaption class="wp-element-caption">Johan Untersteiner  Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Både Solvalla och Boden bjuder på tvååringslopp ikväll med nio respektive sju startande hästar.<br>I Boden har hemmatränaren Petri Salmela laddat rejält och tränar fyra av sju hästar. Salmela är också delad tvåa i Sverige när det gäller antalet segrar med tvååringar 2023. Tre segrar har hans ungdomar räknat in hittills i år och de tre vinnarna möts ikväll: <strong>Oy Vey </strong>(e. Captain Corey), <strong>Epicure U.S.</strong> (e. Gimpanzee) och <strong>Elle Driver</strong> (e. Captain Corey).</p>



<p class="wp-block-paragraph">Tre vinnare på svensk mark har också Paul Hagoort med filial på Solvalla och denne har en duo i tvååringsloppet på Solvalla.</p>



<p class="wp-block-paragraph">Totalt har 33 svensktränade tvååringar vunnit lopp i Sverige i år och bäst i klassen är Johan Untersteiner. Fem av stallets tvååringar har tävlat och fyra har vunnit lopp!</p>



<h2 class="wp-block-heading">Tränare med flest tvååringssegrar i Sverige 2025</h2>



<p class="wp-block-paragraph"><em>Tränare, hemmabana – Antal segrar (antal vinnare)</em></p>



<ul class="wp-block-list">
<li>Johan Untersteiner, Halmstad – 8 (4)</li>



<li>Petri Salmela, Boden – 3 (3)</li>



<li>Paul Hagoort, Solvalla – 3 (3)</li>



<li>Claes Sjöström, Solvalla – 2 (2)</li>



<li>Daniel Wäjersten, Bergsåker – 2 (2)</li>



<li>Fredrik B Larsson, Solvalla – 2 (1)</li>



<li>Joakim Elfving, Romme – 2 (1)</li>



<li>Åke Lindblom, Örebro – 2 (1)</li>



<li>Timo Nurmos, Solvalla – 2 (1)</li>



<li>Robert Dunder, Bergsåker – 2 (1)</li>



<li>Jasmine Ising, Romme – 2 (1)</li>
</ul>



<p class="wp-block-paragraph"><strong>Dessa tränare har en tvååringsvinnare vardera:</strong> Christoffer Eriksson, Åby, Hanna Forslin, Hagmyren, Björn Goop, Färjestad, Ville Karhulahti, Solvalla, Adrian Kolgjini, Jägersro, Oskar Kylin Blom, Gävle, Stefan Larsson, Tingsryd, Viktor Lyck, Rättvik, Hanna Olofsson, Boden, Hanna Rexhammar, Romme, Sandra Stuxberg, Visby, Fredrik Wallin, Gävle, Anders Wester, Mantorp.</p>



<p class="wp-block-paragraph"><em>Statistiken gäller svenska tränares starter i Sverige.</em></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/2025/10/kilmister2025courantstable-617x347.jpg" alt="" class="wp-image-784296"/><figcaption class="wp-element-caption">Kilmister blir avelshingst i Kanada nästa år. Foto Stall Courant</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Stall Courants <strong>Kilmister</strong> (e. Chapter Seven-Treviso), 1.08,7ak*/8.785.261 kr, blir avelshingst i Kanada och gör sin första säsong på Tara Hills Stud i Ontario. Prislappen för hans tjänster är satt till 5.000 kanadensiska dollar. </p>



<p class="wp-block-paragraph">Karriären inrymde nio segrar – en av dem togs på svensk mark i regi Sabine Kagebrant – och innan Chapter Seven-sonen kom till Sverige tävlade han för Marcus Melander i USA. Där tog han sin största seger i Peter Haughton Memorial ($337.000)</p>



<p class="wp-block-paragraph">Anders Ström betalade 170.000 dollar för Kilmister i Lexington som ettåring och hingsten är undan <strong>Treviso</strong> (e. Muscle Massive), 1.10,3*/$330.515, som också lämnat tvååriga <strong>Denarius</strong> (C$131.961) och <strong>Santa Croce</strong> (C$114.233). </p>



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



<p class="has-drop-cap wp-block-paragraph">51.115 meter långa banan i Beaumont de Lomagne strax norr om Toulouse i södra Frankrike bjuder på storlopp idag utan svenskt deltagande – men också en del blågult i startlistorna när både Jörgen Westholm, Johan Untersteiner och Conrad Lugauer har häst till start.</p>



<p class="wp-block-paragraph">Alexandre Abrivard är tillbaka i sadeln på Westholms franska succé <strong>Ninepoints Lasse</strong> (e. Uncle Lasse) som tagit nio segrar på 22 försök sedan Westholm skickade honom söderut. Nu ligger 34.000 euro i prispotten, varav 15.300 euro till vinnaren, i montéloppet över 2.550 meter.<br>Bland motståndarna finns Lugauers <strong>Leroy Boko</strong> (e. Trixton), som debuterade på fransk mark nyligen med en femteplats i monté.</p>



<p class="wp-block-paragraph">Untersteiners <strong>Mateo di Quattro</strong> (e. Bird Parker) inledde franska äventyret i vintras och våras på bästa sätt med tre segrar och två andraplatser på de fem första starterna. Nu jagar han första vinsten på drygt fem månader i ett sulkylopp över 2.400 meter med autostart och 15.300 euro i förstapris.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2024/12/tenordebaune3-617x352.jpg" alt="" class="wp-image-672305" style="width:617px;height:auto"/><figcaption class="wp-element-caption">Blivande Prix d&#8217;Amérique-tvåan Just Love You och Alexandre Abrivard vinner före Jörgen Westholms Working Class Hero i Prix Tenor de Baune i vintras. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Den 48:e upplagan av Grand Prix du Sud-Ouest (€200.000) avgörs också idag. Grupp II-loppet körs över 2.400 meter med 90.000 euro till vinnaren. <br>Dit åker bland annat Alexandre Abrivard med årets Prix d’Amérique-tvåa <strong>Just Love You </strong>(e. Love You) och bland motståndarna finns segermaskinen <strong>Ino du Lupin</strong> (e. Scipion du Goutier) och Nicolas Bazires nybakade storloppsvinnare <strong>Hymne du Gers</strong> (e. Bold Eagle). </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/beaumont-de-lomagne-2025-10-22/" 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">6Årets norske Derbyvinnare <strong>Gigant Tider</strong> (e. Norheim Svenn), 1.23,2am/&#038;2.146.435 NOK, har tävlat färdigt för i år. Tanken var att göra två starter till i Norge i höst, i höstfinalen och finalen av kallblodscupen, men så blir det inte <a href="https://tgn.no/sport/ma-avslutte-sesongen-tidligere-enn-planlagt/19.31296" target="_blank" rel="noreferrer noopener">rapporterar Trav- og Galopp-Nytt</a>.</p>



<p class="wp-block-paragraph">Gigant Tider galopperade bort sig hemma på Forus förra veckan och blev diskvalificerad – första gången han inte slutade topp-två i lopp! <br>– Vi kollade upp honom och det visade sig att han hade ont i knäna. Vi siktar på att ta ut honom tidigt nästa år. Han ska verka i aveln sedan och i samband med det blir det inte så mycket tävling, utan därför blir det några starter tidigt på säsongen istället, säger tränaren Kjetil Djöseland till TGN.</p>



<p class="wp-block-paragraph">Gigant Tider vann norska Kriteriet ifjol och alltså Derbyt tidigare i höst, men var inte anmäld till de svenska klassikerna. Fyraåringen har gjort en start i Sverige, när han vann Prinsessan Madeleines Pokal i Bollnäs i maj. Totalt har han gjort 17 starter (13-3-0).</p>



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



<p class="has-drop-cap wp-block-paragraph">7Kungen bland de danska tvååringarna hittills är <strong>Menza</strong> (e. Readly Express). Med fyra segrar på lika många starter och goda rekordet 1.14,6ak från tävlingsdebuten kommer Gordon Dahls travare ut som storfavorit i ett av två försök till Dansk Uppfödningslöpning på Charlottenlund ikväll.<br>Han möter två obesegrade hästar, <strong>Mester C.N.</strong> (e. Ens Snapshop) som vunnit två lopp och <strong>Margrethe</strong> (e. Calgary Games) som inledde med vinst i debuten.</p>



<p class="wp-block-paragraph">I det andra försöket finns den ende svensktränade deltagare i Per Nordströms hingst <strong>Maigaardlovescosta</strong> (e. Readly Express), som var knappt slagen tvåa i debuten i Halmstad för knappt tre veckor sedan.<br>Steen Juuls <strong>Monterey Market</strong> (e. Googoo Gaagaa) har främsta meriten i loppet efter andraplatsen i Jydsk 2-årings Grand Prix bakom Menza. Monterey Market har inlett karriären med fyraraka andraplatser.</p>



<p class="wp-block-paragraph"><strong>Dansk Uppfödningslöpning – Charlottenlund</strong></p>



<p class="wp-block-paragraph"><strong>Försök 1<br></strong>2.000 meter autostart:<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Menza</strong> (e. Readly Express) – Birger Jörgensen</li>



<li><strong>Meslois</strong> (e. Southwind Frank) – Jim G Veldman</li>



<li><strong>Margrethe</strong> (e. Calgary Games) – Ken Ecce</li>



<li><strong>Master Hans</strong> (e. Maharajah) – Nicklas Korfitsen</li>



<li><strong>Makememoni M.S.</strong> (e. International Moni) – Michael Lönborg</li>



<li><strong>Mikado</strong> (e. Great Challenger) – Jeppe Juel</li>



<li><strong>Mester C.N.</strong> (e. Ens Snapshop) – Jan Dahlgaard</li>



<li><strong>Maserati Flamingo</strong> (e. Ens Snapshop) – Steen Juul</li>



<li><strong>Maddie S.</strong> (e. Wishing Stone) – Knud Mönster</li>
</ol>



<p class="wp-block-paragraph"><strong>Försök 2</strong><br>2.000 meter autostart:<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Messi Hill</strong> (e. Calgary Games) – Jeppe Juel</li>



<li><strong>Marabou</strong> (e. Calgary Games) – struken</li>



<li><strong>Madame</strong> (e. Varenne) – Nicklas Korfitsen</li>



<li><strong>Maximus Mosebo</strong> (e. Dominion Beach) – Rene Kjaer</li>



<li><strong>Maigaardlovescosta</strong> (e. Readly Express) – Per Nordström</li>



<li><strong>Monterey Market</strong> (e. Googoo Gaagaa) – Steen Juul</li>



<li><strong>Milady</strong> (e. Maharajah) – Jan Dahlgaard</li>



<li><strong>Monkey Osted Antik</strong> (e. International Moni) – Michael Lönborg</li>



<li><strong>Mathilde Boom Bay</strong> (e. O’Grady) – Knud Mönster</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
En fighter tillbaka i Sverige
Vunnit elva av 17 starter i nya hemlandet. Nurmos/Djuse sitter på nyckeln. Alla tränare som vunnit tvååringslopp. Från Sverige till Kanada – som avelshingst. Svenskmöte i Frankrike.
Detta och mer bland onsdagens nyheter.
Detta och mer bland onsdagens nyheter.
