
<p class="has-drop-cap wp-block-paragraph">11.12,0a/2.640 meter. Det är tiden att slå om man vill ta över löpningsrekordet i Svenskt Travkriterium när finalen av årets upplaga avgörs på Solvalla i eftermiddag.</p>



<p class="wp-block-paragraph">Timo Nurmos är tränaren bakom <strong>Villiam</strong> (e. Muscle Hill), som satte löpningsrekord för sju år sedan och Timo kan skriva ny historia ikväll på Solvalla. Vinner Knoxville (e. Nuncio) blir Timo bäst genom tiderna i Svenskt Travkriterium med nio tränarvinster! Just nu delar han ledningen med Gunnar och Sören Nordin på åtta triumfer.<br>Timo Numos åtta vinnare är <strong>Marquis du Pommeau</strong> 2006, <strong>Sahara Dynamite</strong> 2007, <strong>Red Hot Dynamite</strong> 2009, <strong>Chelsea Boko</strong> 2012, <strong>Readly Express</strong> 2015, <strong>Villiam</strong> 2017, <strong>Inti Boko</strong> 2018 och <strong>Fame and Glory</strong> 2023. </p>



<p class="wp-block-paragraph">Bakom <strong>Omega River</strong> (e. Tactical Landing) står fjolårets tränar- och kuskvinnare Daniel Wäjersten och de senaste två årens vinnande hästägare Stall Sofo. Stefan Lundborgs bolag äger nämligen både 2023 års vinnare Fame and Glory (e. Tactical Landing) och fjolårets kung Bullet the Bluesky (e. Readly Express).<br>– Omega River har bra styrka och han har fin moral. Han känns väldigt bra för dagen och jag hoppas flytet håller i sig för ägarna, säger Daniel Wäjersten.</p>



<p class="wp-block-paragraph"><strong>Snabbaste vinnarna av Svenskt Travkriterium</strong><br><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2017 Villiam (e. Muscle Hill) – Jorma Kontio (Timo Nurmos) – 1.12,0a</li>



<li>2023 Fame And Glory (e. Tactical Landing) – Björn Goop (Timo Nurmos) – 1.12,5a</li>



<li>2021 Francesco Zet (e. Father Patrick) – Örjan Kihlström (Daniel Redén) – 1.12,7a</li>



<li>2015 Readly Express (e. Ready Cash) – Jorma Kontio (Timo Nurmos) – 1.12,8a</li>



<li>2024 Bullet the Bluesky (e. Readly Express) – Daniel Wäjersten – 1.12,8a</li>



<li>2022 Xanthis Harvey (e. Propulsion) – Örjan Kihlström (Daniel Redén) – 1.12,9a</li>



<li>2019 Power (e. Googoo Gaagaa) – Robert Bergh – 1.13,0a</li>



<li>2016 Deimos Racing (e. Quite Easy) – Erik Adielsson (Svante Båth) – 1.13,1a</li>



<li>2020 Brambling (e. Bold Eagle) – Örjan Kihlström (Daniel Redén) – 1.13,1a</li>



<li>2013 Rokkakudo (e. Varenne) – Ulf Ohlsson (Anna Forssell) – 1.13,5a</li>



<li>2018 Inti Boko (e. Chocolatier) – Johnny Takter (Timo Nurmos) – 1.13,5a</li>
</ul>



<p class="wp-block-paragraph"><a href="https://publikationer.se/sulkysport/kriterienummer-2025/" target="_blank" rel="noreferrer noopener">Smått &#038; gott om alla hästar i Kriteriet finns i Sulkysports Kriterienummer här!</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/2025/06/kobrabrickmfm250628adamstromstalltz-1-617x399.jpg" alt="" class="wp-image-737454"/><figcaption class="wp-element-caption">E3-vinnaren Kobra Brick och Mika Forss. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Ulf Nordins <strong>Prophet Jill</strong> (e. The Prophet) var den första historiska vinnaren av Svenskt Trav-Oaks när hon slog till i premiärupplagan 1979. Då räckte det att trava 1,20,8 för att plocka hem förstapriset på 30.000 kronor.</p>



<p class="wp-block-paragraph">Under andra halvan av 1980-talet var Kriteriestoet det stora loppet som avgjordes på Kriteriedagen, men sedan Tommy Hanné-tränade <strong>Eva Prides</strong> (e. Count’s Pride) seger 1991 med Torbjörn Jansson i sulkyn har Oaks fått sin rätta plats i kalendern. Det året lyfte prissumman från en kvarts miljon kronor till 682.000 kronor.<br>1.17,1 räckte för seger för Eva Pride för 31 år sedan. När Kenneth Haugstad styrde <strong>Spoil Me</strong> (e. Going Kronos) till vinst 2015 krävdes nytt världsrekord: 1.11,5a/2.140 meter. Den noteringen är fortsatt löpningsrekord för Oaks.</p>



<p class="wp-block-paragraph">Petri Salmela-tränade <strong>Kobra Brick</strong> (e. Readly Express) har tjänat mest av stona i årets finalfält, men fick nöja sig med andraplatsen i försöket.<br>– Marginalerna är mindre den här tiden på säsongen och det är klart att det blir svårt från spår elva, men samtidigt kan man drömma om att hon är så pass bra att hon rundar dem alla, säger Petri Salmela.</p>



<p class="wp-block-paragraph"><strong>Snabbaste vinnarna av Svenskt Trav-Oaks</strong><br><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2015 Spoil Me (e. Going Kronos) – Kenneth Haugstad (Roger Walmann) – 1.11,5a</li>



<li>2024 Vivillion (e. Propulsion) – Daniel Wäjersten – 1.11,7a</li>



<li>2018 Conrads Rödluva (e. S.J.’s Caviar) – Örjan Kihlström (Daniel Redén) – 1.11,9a</li>



<li>2022 Bonneville W.I. (e. S.J.’s Caviar) – Ulf Ohlsson (Timo Nurmos)</li>



<li>2021 Lara Boko (e. Djali Boko) – Mika Forss (Timo Nurmos) – 1.12,1a</li>



<li>2016 Darling Mearas (e. Cantab Hall) – Stefan Persson – 1.12,5a</li>



<li>2023 Adriatica (e. Bold Eagle) – Magnus A Djuse (Timo Nurmos) – 1.12,5a</li>



<li>2017 Candy La Marc (e. Scarlet Knight) – Erik Adielsson (Lars Marcussen) – 1.12,6a</li>



<li>2020 Eagle Eye Sherry (e. Bold Eagle) – Stefan Persson (Björn Goop) – 1.13,1a</li>



<li>2019 Diana Zet (e. Hard Livin) – Örjan Kihlström (Daniel Redén) – 1.13,5a</li>
</ul>



<p class="wp-block-paragraph"><a href="https://publikationer.se/sulkysport/kriterienummer-2025/" target="_blank" rel="noreferrer noopener">Smått &#038; gott om alla hästar i Oaks finns i Sulkysports Kriterienummer här!</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/2025/07/donfanuccizetmalgangmiro-617x333.jpg" alt="" class="wp-image-749598"/><figcaption class="wp-element-caption">Don Fanucci Zet fäller fram öronen, kollar in fotograferna och vinner Hugo Åbergs 2025. Foto Mikael Rosenquist/MiRo Media</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Två år i rad har Europafinalen UET Elite Circuit för äldre hästar och Europaderbyt Grand Prix de l’U.E.T. avgjorts samma dag på samma bana. På Solvalla för två år sedan blev det franskt i de äldre finalen genom <strong>Hohneck</strong> (e. Royal Dream) och svenskt bland fyraåringarna genom <strong>Barack Face</strong> (e. Ready Cash), tränad av Adrian Kolgjini.<br>Ifjol var rollerna ombytta när franske <strong>Go On Boy</strong> (e. Password) var väst bland de äldre och Daniel Redén-tränade <strong>Epic Kronos</strong> (e. Muscle Hill).</p>



<p class="wp-block-paragraph">Årets upplagor ser svenskt i favoritroll i båda loppen.</p>



<ul class="wp-block-list">
<li>Mångmiljonären <strong>Don Fanucci Zet </strong>(e. Hard Livin) och Örjan Kihlström i UET Elite Circuit:<br>– Jag körde jobb med honom i måndags och han kändes jättefin. Ingenting tyder på att han ska vara sämre än tidigare. Han har gått med skor runt om nu i två starter och kommer att få en fin kick av att ta av dem igen, säger Daniel Redén till Stall Zets hemsida.</li>
</ul>



<ul class="wp-block-list">
<li>Jörgen Westholms svenske Derbyvinnaren <strong>Dream Mine</strong> (e. Maharajah) i Grand Prix de l’U.E.T:<br>– I Derbyt kändes han inte helt som jag trodde att han skulle göra första stegen, men han hade lite tyngre framboots då. Han är förnuftig och lättsam och jag tror att han kommer att öppna väldigt bra. Jag har bra känsla, han har varit fin en längre tid och inget tyder på att han ska vara sämre, sade kusken Mats E Djuse om Dream Mine till V65 Direkt.</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">462.241.315 kronor finns kvar i ATG:s fond av uteblivna vinstutbetalningar på V75, enligt spelbolagets hemsida, och hela potten eller åtminstone en del av dem, kommer att läggas i åttarättspotten vid V85-premiären på Jägersro om två veckor.</p>



<p class="wp-block-paragraph">Vägen till miljonerna idag? Singelstreck i både Kriteriet och Oaks enligt vår spelpartner Simsalabim!<br><a href="https://sulkysport.se/spelstugan/v75-tips-nordstroms-jackpotspik/" target="_blank" rel="noreferrer noopener">––> Här är hela tipsgenomgången till V75 idag.</a></p>



<p class="wp-block-paragraph">V75-jackpot: Vill Du spela V75 med Simsalabim och ta fel av en andel i systemförslaget?<br><a href="https://www.atg.se/simsalabim/spel/296591_V75_2025-10-11_5_7" target="_blank" rel="noreferrer noopener">Här finns andel i systemförslaget för 150 kr/andel</a></p>



<p class="wp-block-paragraph">När Solvalla slår igen superlördagen avrundar Åby (första start  </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/2021/10/kriteriestatyett2genre-617x333.jpg" alt="" class="wp-image-226424"/><figcaption class="wp-element-caption">Kriteriestatyett. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5På tal om miljonrullning…26.869.500 kronor delas ut på Solvalla idag! Det är den näst högsta summan någonsin på en svensk tävlingsdag och överträffas endast av motsvarande tävlingsdag på Solvalla för två år sedan, då totala prissumman fick en extra skjuts uppåt av dubbla pengarna för premiechansade hästar i Kriteriet och Okas, medan årets upplaga ”bara” erbjuder 50 procent extra i prispengar i treåringarnas största lopp.</p>



<p class="wp-block-paragraph"><strong>Hägsta prissummorna på en svensk tävlingsdag:</strong></p>



<ol class="wp-block-list">
<li>14 oktober 2023 – Solvalla – Kriteriedagen* &#038; UET-finaler – 28.674.000 kr</li>



<li>11 oktober 2025** – Solvalla – Kriteriedagen* &#038; UET-finaler – 26.869.500 kr</li>



<li>25 maj 2025 – Solvalla – Elitloppet – 21.586.000 kr</li>



<li>26 maj 2024 – Solvalla – Elitloppet – 20.835.000 kr</li>



<li>12 oktober 2024 – Solvalla – Kriteriedagen – 19.793.000 kr</li>



<li>24 september 2022 – Solvalla – Kriteriedagen – 19.678.000 kr</li>



<li>28 maj 2023 – Solvalla – Elitloppet – 19.641.000 kr</li>



<li>29 maj 2022 – Solvalla – Elitloppet – 18.726.000 kr</li>



<li>29 september 2013 – Solvalla – Kriteriedagen* &#038; UET Grand Prix – 16.830.400 kr</li>



<li>25 september 2021 – Solvalla – Kriteriedagen* – 16.768.500 kr</li>
</ol>



<p class="wp-block-paragraph"><em>* Prispengar inklusive premiechansen.</em><br><em>** Preliminär total prissumma.</em></p>



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



<p class="has-drop-cap wp-block-paragraph">6Förra året var det stor succé för svensktränade hästar när Petri Salmela-tränade <strong>Lilium Sisu </strong>(e. Face Time Bourbon) vann norskt Oaks på varmblodssidan tillsammans med Mika Forss och Anders Wallin-tränade svenskfödda <strong>Björgen</strong> (e. Bork Odin) lotsades till lätt spetsvinst av Per Linderoth.</p>



<p class="wp-block-paragraph">Ikväll är det dags för årets upplagor av treåringsloppen på norska Momarken, men det blir ingen repris från fjolåret. Ingen svensktränad häst finns nämligen med i årets upplagor med 300.000 kronor i loppen.</p>



<p class="wp-block-paragraph">På varmblodssidan skulle det ha blivit ett första möte mellan stallkamraterna <strong>A.V.’s Shannon</strong> (e. Nuncio) och <strong>Catchagaga Volo</strong> (e. Googoo Gaagaa), som vann varsin avdelning i Biris Treåringselit i somras. Sen sistnämnda följde upp med vinst i Stokriteriet, medan A.V.’s Shannon slutade femma mot hingstarna i Kriteriet.<br>Nu blir dock inte mötet av mellan Erlend Rennesviks treåriga ston – A.V.’s Shannon har fått strykas och vägen ligger öppen för en tredje storseger i år för Catchagaga Volo.</p>



<p class="wp-block-paragraph">På kallblodssidan saknas Sandra Erikssons vinnare av Stokriteriet, <strong>Tekla</strong> (e. Tekno Odin), medan Norge ställer upp med de vassaste stona, som Jan Roar Mjölneröds vinnare av Kriteriestoet på Dannero <strong>Kleppe Nissemor</strong> (e. Norheim Svenn).</p>



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



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



<p class="has-drop-cap wp-block-paragraph">7Ett av Finlands största treåringslopp är Kymenlaakso-Ajo (€90.000) i Kouvola, där vinnaren plockar hem 40.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">Fyra försök kördes i Kouvola för nio dagar sedan. Av hästarna på startfållan segrade <strong>Prasutagus Secret</strong> på 1.15,0, medan övriga tre försöksvinnare hittades från tillägg i <strong>Fuego Combo</strong> på 1.15,0, <strong>Piccolo Cocktail</strong> på 1.15,1 och <strong>Shackhills Gambler</strong> på 1.15,7.<br>Pekka Korpis segermaskin Fuego Combo har vunnit 14 av 21 starter, men fick nöja sig med sjundeplatsen i finska Kriteriet efter att ha vunnit försöket som 1.20-favorit. Sedan dess har han plockat ytterligare två vinster.</p>



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



<p class="wp-block-paragraph">2.100 meter voltstart, Kouvola lördag<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li>Go Gaga (e. Googoo Gaagaa) – Iikka Nurmonen</li>



<li>Prasutagus Secret (e. Tobin Kronos) – Olli Koivunen</li>



<li>Stonecapes Yoda (e. Southwind Frank) – Ari Moilanen</li>



<li>Birchwood Beast (e. Quite Easy) – Jani Routsalainen</li>



<li>Will Be Back (e. Citation Lindy) – Tapio Perttunen</li>



<li>Mudcake Comery (e. Wishing Stone) – Tommi Kylliäinen</li>



<li>Franc Arrow (e. Friendly Bourbon) – Santtu Raitala <br><em>2.120 meter:</em></li>



<li>Shackhills Gambler (e. Jontte Boy) – Tuukka Varis</li>



<li>Fuego Combo (e. Express Duo) – Pekka Korpi</li>



<li>Piccolo Cocktail (e. Maharajah) – Jarmo Saarela</li>



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



<li>El Narnia (e. E L Titan) – Hannu-Pekka Korpi</li>
</ol>
