
<p class="has-drop-cap"><strong>1</strong> <strong>Najo</strong> (e. Adept-Jaja) är en av Örebrotravets stora profiler genom åren. Tillsammans med sin tränare Rune &#8221;Snoddas&#8221; Johansson vann hästen både Svenskt Travderby och Kungapokalen under fyraåringssäsongen. Hästen hade två starka unghästår och 42 starter som tre- och fyraåring slutade med 15 segrar. Totalt gjorde Najo 57 starter (15–5–3), tjänade 190.125 kronor och travade 1.19,1 som snabbast.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/03/johanssonrunetarzan-617x333.jpg" alt="" class="wp-image-422125"/><figcaption class="wp-element-caption">Rune Johansson. Foto Stalltz.se</figcaption></figure>



<p>Sedan 2002 har hans minne hedrats på Örebrotravet och ikväll är det dags igen för Najos Minne. 100.000 kronor väntar vinnaren i fyraåringsloppet som är öppet för alla hästar som tjänat lägst 190.125 kronor, alltså den summa Najo själv drog in under karriären på 1970-talet.</p>



<p>Årets upplaga håller hög klass med bland annat tre av årets Derbyfinalister bland de tio deltagarna: Maria Törnqvists fyra <strong>Macahan</strong> (e. Maharajah), Daniel Redéns sexa <strong>Holcombe Zet</strong> (e. Daley Lovin) och Johan Untersteiners sjua <strong>Stens Rubin</strong> (e. Readly Express).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/macahancjjm240820adamstromstalltz-617x418.jpg" alt="" class="wp-image-624189"/><figcaption class="wp-element-caption">Macahan vann försök till Svenskt Travderby. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Flera utlandsfödda sticker också ut. Som sjufaldige miljonären <strong>Kilmister</strong> (e. Chapter Seven), som gjort blott en start på svensk mark i år som trea i Kungapokalskval. Hästen tvingades sedan strykas från finalen.</p>



<p>Alessandro Gocciadoros svenskfödde hingst <strong>Killiam Fromentro </strong>(e. Villiam) har vunnit dubbla avdelningar i Margareta Tidiga Unghästserie, samt Prix Readly Express i år.</p>



<h2 class="wp-block-heading">Snabbaste vinnarna av Najos Minne</h2>



<p><strong>År, häst (far) – Kusk (tränare) – Segertid</strong></p>



<p>2016 <strong>Cruzado Dela Noche</strong> (e. Muscle Massive) – Björn Goop (Stefan Melander) – 1.11,1am<br>2023 <strong>Double Deceiver </strong>(e. Cantab Hall) – Örjan Kihlström (Daniel Redén) – 1.11,9am<br>2017<strong> Love Matters </strong>(e. Explosive Matter) – Örjan Kihlström (Daniel Redén) – 1.12,7am<br>2021 <strong>Bandido Gar </strong>(e. Maharajah) – Jorma Kontio (Susanne Richter) – 1.13,0am<br>2014 <strong>Call Me Keeper </strong>(e. Pine Chip) – Daniel Redén – 1.13,3am<br>2018<strong> Lucifer Lane</strong> (e. Infinitif) – Johan A Nilsson (Thomas L Nilsson) – 1.13,4am</p>



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



<p class="has-drop-cap">2 På Bergsåker står idel kallblodslopp på programmet – tionde året i rad en heldag med bara kallblod på Bergsåker – och kvällens höjdare är Svenskt Mästerskap i monté med 125.000 kronor till vinnaren.</p>



<p>Mästerskapet har avgjorts sedan 2011, då <strong>Ivarsqvick</strong> (e. Qvadrigo) segrade tillsammans med Stina Swartling. Don Viking (e. Järvsöviking) är den mest framgångsrike i historien med sina tre segrar, medan <strong>Wilda Fille </strong>(e. Bork Odin) tagit två titlar. De första två upplagorna avgjordes över flera volter, medan det 2013-2022 handlade om autostart. Efter fjolårets mästerskap i voltstart med hästar på tre volter är det åter bilstart som gäller ikväll.</p>



<p>Anna Frössevi Ericsson-tränade <strong>Klack Silver</strong> (e. Klack Jo) triumferade tillsammans med Sofia Adolfsson förra året, då hästen stod på startfållan. Nu väntar alltså lika start för deltagarna de tolv deltagarna där hälften är miljonärer eller dubbelmiljonärer.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/08/donviking2-617x333.jpg" alt="" class="wp-image-204969"/><figcaption class="wp-element-caption">Don Viking. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Och den mest meriterade i startfältet – i dubbel bemärkelse – är 15-årige <strong>Don Viking</strong>. Stefan Dellbros tuffing som rest sig gång efter gång efter skador gör en av livets sista starter när han tillsammans med ständiga följeslagaren i sadeln, Lena Fritz, jagar ett fjärde och sista SM-guld.</p>



<p>De två formstarkaste korten i loppet ramar in SM-fältet. Robert Skoglunds <strong>Sundbo Komet </strong>(e. Sundbo Kravall) från innerspår och Jörgen Westholm-tränade <strong>Guli Fantom</strong> (e. Bork Odin) från spår tolv. Den förstnämnde har tre raka montétriumfer i resultatraden, medan Guli Fantom kommer från två sulkysegrar. I hästens enda start under sadel – i december förra året – vann hästen och utklassade bland andra Sundbo Komet.</p>



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



<p class="has-drop-cap">3 V86 Super Days går vidare och <strong>Örebro</strong> (första start 18.15) delar alltså expressomgången med <strong>Bergsåker</strong> (första start 18.27). Förutom nämnda storlopp finns fler godbitar på banorna.</p>



<p>I en spårtrappa i Örebro är det stor spännvidd från innerspårets <strong>Friend of Elves</strong> (e. Oasis Bi) med 1,2 miljoner på kontot till tolftespårets <strong>Milliondollarrhyme</strong> (e. Ready Cash) med nästan nio miljoner insprunget. </p>



<p>Ett fem- och sexåringslopp på Bergsåker ser två av kullens allra främsta femåringar i <strong>Envis</strong> (e. Lome Brage) och Broline (e. Lome Brage) och ytterligare två hästar från Jan-Olov Perssons stall, däribland Stjärnblomsters son <strong>Blomsterprinsen</strong> (e. Smedheim Solan). </p>



<p>Torsdagen inleds med lunchtävlingar i <strong>Visby</strong> (start 12.20), där det efter dagens lopp återstår tre tävlingsdagar av säsongen. Hemmamatören Anette Flodmans fyraåring <strong>Heads or Tails </strong>(e. Coin Pedru) har hittat lysande sommar- och höstform med tre segrar och ett andrapris på de fyra senaste starterna. Nu brottas han med bricka tolv över sprinterdistans i en spårtrappa i jakten på en ny triumf.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/09/240926.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2024/09/240926.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till torsdagens tävlingar. </a></p>



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



<p class="has-drop-cap">4 Tre rikstotolopp har Elke Frintas <strong>Enjoy the Moment (</strong>e. Propulsion), 1.10,9ak*/789.400 kr, vunnit under sommaren och sedan en tid tillbaka finns den femårige valacken på fransk mark.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/enjoythemomentpnm240814adamstromstalltz-617x401.jpg" alt="" class="wp-image-621917"/><figcaption class="wp-element-caption">Enjoy the Moment. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>– Tanken är att jag ska köra honom i ett lopp på Enghien den 7 oktober, säger Per Nordström.</p>



<p>Det handlar om ett europeiskt lopp – Prix des Buttes Chaumont (€46.000) för femåriga hingstar/valacker över distansen 2.875 meter med 20.700 euro i förstapris.</p>



<p>Per Nordström kan också berätta att han fått in norske segermaskinen<strong> Thai M. Square</strong> (e. Broadway Hall-Thai Gucci), 1.12,1am*/934.927 nok, som vunnit 25 av 38 starter. I sin senaste start slutade Thai M. Square tvåa på Haugaland Travpark bakom Deep Sea Lucky (e. Panne de Moteur), som vunnit 15 lopp i år. För Thai M. Square har det blivit fyra segrar på tio starter hos Pål Buer.</p>



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



<p class="has-drop-cap">5 Åby Yearling Sale slår upp portarna idag och auktionen drar igång klockan 18.00. Under två dagar ska det säljas ettåringar i Mölndal och närmare 200 hästar bjuds ut.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/09/eusebioface.jpg" alt="" class="wp-image-502611"/><figcaption class="wp-element-caption">Eusebio Face var dyrast på Åby Yearling Sale förra året. Foto Lina Alm Racing Media</figcaption></figure>



<p>Förra året såldes 145 ettåringar på auktionen och två hästar kostade sjusiffrigt; Eusebio Face (e. Chapter Seven-Gold Coast) klubbades för 2,5 miljoner och Bedazzled Soxs halvbror Lover Cook (e. Love You-Out of the Kitchen) såldes för 1,8 miljoner.</p>



<p><a href="https://sulkysport.se/637520-2/" data-type="link" data-id="https://sulkysport.se/637520-2/" target="_blank" rel="noreferrer noopener">Läs mer om auktionen här.</a></p>



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



<p class="has-drop-cap">6 Lutfi Kolgjini flyttade sin auktion till Eskilstuna efter strul med tekniken och fick ett bra utfall på Sundbyholmstravet när hans hästar såldes i samband med ASVT:s auktion. Snittpriset landade på 607.500 kronor och det är det högsta hittills för en auktion i Europa.</p>



<p>– Nästa år flyttar vi tillbaka auktionen till Vomb och de blir på lördagen, alltså dagen före Svenskt Travderby och det blir enbart en fysisk auktion. Alla buden tas på plats, säger Lutfi Kolgjini.</p>



<p>Även ASVT/Trottex kommer att arrangera en auktion i Skåne i samband med Derbyt och det på Jägersro på fredagen.</p>



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



<p class="has-drop-cap">7 Idag drar Lexingtons stora meeting igång på Red Mile med Bluegrass Series ($77.300) för tvååriga hingstar och valacker. I den första divisionen startar Lucas Wallin i två starter obesegrade och toppstammade <strong>The Rogue Prince</strong> (e. Walner-Check Me Out).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/wallinlucasp230804adamstromstalltz-617x833.jpg" alt="" class="wp-image-483372"/><figcaption class="wp-element-caption">Lucas Wallin startar två obesegrade tvååringar på Red Mile idag. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Fyra blågultränade travare är det i andra divisionen och där plockar Lucas Wallin också ut svenskfödde <strong>Maximus Mearas </strong>(e. Chapter Seven-Darling Mearas), som inte vet hur det känns att förlora efter två starter. Han ställs mot Marcus Melanders topptvååring <strong>Super Chapter</strong> (e. Chapter Seven-Lifetime Pursuit), Jim Oscarssons svenskfödde <strong>Themoneyisback</strong> (e. Aperfectyankee-Dontlooseallmoney) och Åke Svanstedts <strong>Warrior </strong>(e. Walner-Like A Lindy).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/07/superchapter2572024mikelizzi-617x411.jpg" alt="" class="wp-image-614089"/><figcaption class="wp-element-caption">Super Chapter och Dexter Dunn vid en tidigare seger. Foto: Mike Lizzi</figcaption></figure>



<p>I tredje divisionen tar Marcus Melander ut <strong>Go Boom </strong>(e. Muscle Hill-Ilia), Åke Svanstedt svenskfödde <strong>Gap Kronos </strong>(e. Face Time Bourbon-I’m Really Special), Jim Oscarsson <strong>Portillo </strong>(e. Tactical Landing-Rarely Wrong) och Nancy Takter <strong>Civilian Drone</strong> (e. Chapter Seven-Southwind Snow).</p>



<p>I fjärde divisionen startar Nancy Takter <strong>Channing </strong>(e. Propulsion-Stella Jane) och Marcus Melander <strong>Blank </strong>(e. Gimpanzee-Cover Girl), medan den femte divisionen innehåller Melanders <strong>Mountcastle </strong>(e. Muscle Hill-Gama Bourbon), Nancy Takter <strong>Hard Seven</strong> (e. Chapter Seven-Whispering Oaks), Åke Svanstedt <strong>Happy Jack B</strong> (e. Chapter Seven-Exotic Form) och Jim Oscarsson <strong>Durante Hanover</strong> (e. Walner-Dancing For Money).</p>



<p><a href="https://racing.ustrotting.com/goto.aspx?target=12,96996" data-type="link" data-id="https://racing.ustrotting.com/goto.aspx?target=12,96996" target="_blank" rel="noreferrer noopener">Samtliga startlistor hittar ni här.</a></p>
