
<p class="has-drop-cap">1Det vimlar av talanger och segervana hästar på Solvalla (första start 18.20) ikväll när den fjärde och sista omgången av Margaretas Tidiga Unghästserie avgörs. </p>



<p>En som redan vet hur det känns av vinna ett Margareta-lopp är Markus Pihlström-tränade <strong>Googoo Fairytale</strong> (e. Googoo Gaagaa), som är mest meriterad bland de treåriga hingstarna och valackerna. Hästen slog till i förra omgången på Solvalla i början av maj och har vinnit tre av årets fem starter.<br>Bland motståndarna märks Paul Hagoort-tränade <strong>Peaky Blinder Boko</strong> (e. Robert Bi), som var fyra i Breeders Course-finalen för tvååringar och även kvalade in till treåringarnas final under Elitloppshelgen. Meriterna till trots – Peaky Blinder Boko väntar fortfarande på första segern efter sju försök.</p>



<p>I stoklassen för de yngsta är Hagoort-tränade <strong>Mamma Mia Sisu</strong> (e. Walner) rikast bland deltagarna. Hon vann bland annat försök till Svensk Uppfödningslöpning i höstas och tog hem Vårfavoriten för ston i april.<br>En av utmanarna är Mattias Djuse-tränade <strong>Cala Karamell</strong> (e. Power), som senast tvåa i Guldstoet. Inget av dessa ston var anmälda till E3.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/googoofairytaleuom250509adamstromstalltz-617x388.jpg" alt="" class="wp-image-717634"/><figcaption class="wp-element-caption">Markus Pihlström-tränade Googoo Fairytale och Ulf Ohlsson. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p><strong>Vinnare av Margaretas Tidiga Unghästerie 2025 – treåringar:</strong><br><em>Namn (kön/far) – Körsven – Segertid</em></p>



<ul class="wp-block-list">
<li>Precious Steel (s e. Muscle Hill) – Peter Untersteiner – 1.16,5a</li>



<li>Selmina Venit (s e. Donato Hanover) – Örjan Kihlström – 1.14,9a</li>



<li>Pure Stella (s e. Readly Express) – Jorma Kontio – 1.13,2a</li>



<li>Nightlife In (h e. Day Or Night In) – Carl Johan Jepson – 1.14,0a</li>



<li>Olle Sting (v e. Don Fanucci Zet) – Claes Sjöström – 1.13,8a</li>



<li>Googoo Fairytale (v e. Googoo Gaagaa) – Ulf Ohlsson – 1.13,6a</li>
</ul>



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



<p class="has-drop-cap">2Fyraåringsloppen i Margaretas Tidiga Unghästserie är stängda vid 450.000 kronor, men det hindrar inte att det kan finnas blivande topphästar bland deltagarna.</p>



<p>I hingstklassen radar segermaskinerna upp sig och ett av de tyngsta namnen är <strong>Facetime Dream</strong> (e. Face Time Bourbon). Hästen var tvåa i försök till Svenskt Travkriterium i höstas och var tredjehandsfavorit bakom Bullet The Bluesky och Phantom Express i finalen. Där slutade han dock oplacerad efter en slutrunda i tredjespår.</p>



<p>Sedan dess har han inte synts till på tävlingsbanan innan det är dags ikväll. Bland motståndarna finns stallkamraten <strong>Gio Barosso</strong> (e. Ready Cash), som bland annat vunnit på 1.13,6a över lång distans i vår, <strong>Olli Boko</strong> (e. Propulsion) och Pris Readly Express-trean <strong>Mister Lion</strong> (e. Mister J.P), samt duon <strong>Crowe Motion</strong> (e. Propulsion) och <strong>Marshal</strong> (e. Nuncio), som möttes i klass III-finalen under Elitloppshelgen med Crowe Motion som vinnare.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/09/5ecuriebrodda-617x333.jpg" alt="" class="wp-image-640212"/><figcaption class="wp-element-caption">Ecurie Brodda och Mats E Djuse vid seger i Oakskval förra året. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Känt på hetluften i de största loppen har även jämngamla stona <strong>Arctic </strong>Angel (e. Face Time Bourbon) och <strong>Ecurie Brodda</strong> (e. Ready Cash) gjort. Arctic Angel slutade fyra i finalen av Drotnting Silvias Pokal i maj, medan Ecurie Brodda vann försök till Svenskt Trav-Oaks förra året men gjorde bort sig med galopp i finalen.</p>



<p><strong>Vinnare av Margaretas Tidiga Unghästerie 2025 – fyraåringar:</strong><br><em>Namn (kön/far) – Körsven – Segertid</em></p>



<ul class="wp-block-list">
<li>Tactical Lady (s e. Tactical Landing) – Jorma Kontio – 1.13,9a</li>



<li>S.G. Empress (s e. Readly Express ) – Örjan Kihlström – 1.12,8a</li>



<li>S.G. Empress (s e. Readly Express ) – Örjan Kihlström – 1.12,8a</li>



<li>Ogden Boko (v e. Wishing Stone) – Magnus A Djuse – 1.13,6a</li>



<li>Lando Mearas (v e. Walner) – Daniel Wäjersten – 1.12,5a</li>



<li>L’Amourpourbloanca (e. Face Time Bourbon) – Rick Ebbinge – 1.12,6a</li>
</ul>



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



<p class="has-drop-cap">3Kristian Malmin har dömts till 10.000 kronor i böter för överträdelse av Svensk Travsports Antidopingreglemente. Svensk Travsport hade yrkat att påföljden skulle vara 15.000 kronor, men Svensk Travsports Ansvars- och disciplinnämnd (STAD) valde det lägsta bötesbeloppet. </p>



<p>Kristian Malmins <strong>Oracle Tile</strong> hade behandlats i övervakningsstallet på Åby inför Åby World Grand Prix med produkten Hoof Hardener med 96 timmars karenstid. Från början erhöll Oracle Tile startförbud tills vidare och senare fastslogs en månads startförbud för hästen. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/11/kristianmalmin-617x333.jpg" alt="" class="wp-image-122837"/><figcaption class="wp-element-caption">Kristian Malmin. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>STAD skriver i sitt beslut att det rör sig om en lindrig förseelse och att det saknas skäl att ifrågasatta Kristian Malmins påstående om att det rör sig om ett misstag och att han varit av uppfattningen att behandlingen var tillåten utan karenstid. Med hänsyn till det, det hypotetiskt låga läkemedelsupptaget genom hovarna samt omständigheterna i övrigt bör påföljden bestämmas till ett lågt belopp. <br>Vidare skriver STAD; <em>”Oaktat vad Svensk Travsport angett om ett bötesbelopp beräknat efter bestämmelsen i paragraf 12 – något underlag för den beräkningen finns för övrigt inte i ärendet – anser nämnden att bötesbeloppet kan stanna vid lägsta möjliga, det vill säga 10.000 kronor.”</em></p>



<p>Talan mot STAD:s beslut får föras hos Svensk Travsports Överdomstol och överklagandet ska vara skriftligt och ha kommit in till Svensk Travsport inom 14 dagar. </p>



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



<p class="has-drop-cap">4Dag två av tre för säsongen är det dags för i Lycksele (första start 18.30) när det är dags för kvällstävlingar med Lyckselepokalen för varmblod och Lars Matsons Minne för kallblod som höjdare på förhand.</p>



<p>Lyckselepokalen är ett försök-finallopp, där de sju främsta i två försök går vidare till final senare under kvällen. Där väntar 40.000 kronor på vinnaren.</p>



<p>Kallblodsloppet lockar med samma förstapris och en meriterad trio i <strong>Källsjöviking</strong> (e. Järvsöviking), <strong>Forspärla</strong> (e. Hallsta Lotus) och <strong>Sundbo Komet</strong> (e. Sundbo Kravall) ska bland annat försöka plocka in 60 meter på Roger Nilssons segermaskin <strong>Sjöli Morten</strong> (e. Dotterud Teddy).</p>



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



<p class="has-drop-cap">5<strong>Lucifer Boko </strong>(e. E L Titan) bytte Halmstadregi efter andraplatsen i Lärlingseliten på Solvalla förra året – från Jerry Riordan till Gustav Johansson – och bland framgångarna fanns dubbla andrapris i silverdivisionen under sommaren.</p>



<p>Efter att ha testats i Frankrike och Belgien i ett halvår utan framgång kom hästen tillbaka till Gustav i slutet av mars. Återkomsten på tävlingsbanan lovade gott när han slutade tvåa bakom kapable <strong>Sandokan</strong> (e. Maharajah) på Axevalla och vid dagens lunchtävlingar i Mantorp (första start 12.20) kan det vara dags för första segern sedan början av februari 2024. Sedan dess har hästen nämligen 17 segerlösa starter i rad.<br>Nu står Lucifer Boko bra inne på pengarna från tillägg i ett dubbelklasslopp. </p>



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



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



<p class="has-drop-cap">6Stjärnorna står på rad i Alessandro Gocciadoros stall, men nu ska två av dem lämna stallet. <a href="https://www.travronden.se/travsport/handel/hastagande/tranarbyte/a/topphastar-lamnar-alessandro-gocciadoro" target="_blank" rel="noreferrer noopener">Travronden skriver</a> att fjolårets vinnare av Gran Premio Orsi Mangelli och italienske Derbytrea, <strong>Falco Killer Gar</strong> (e. Varenne), samt snabblopparen <strong>Diamond Truppo</strong> (e. Varenne), som var trea i Sweden Cup förra året, ska lämna stallet.</p>



<p>Ny tränare för duon – som ägs av Pachino Horse S.R.L.S, Italien – ska bli fransmannen Thierry Duvaldestin.</p>



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



<p class="has-drop-cap">7På fredag avgörs Norges motsvarighet till Sprintermästaren, Jarlsberg Grand Prix för fyraåringar med försök och final samma kväll över sprinterdistans. Fast intresset för att vara med i kullens näst största lopp i Norge var minst sagt svalt. Blott tolv hästar anmäldes till försöken och i två sexhästarsfält gör de upp om tio finalplatser. En häst per försök slås alltså ut.</p>



<p>Fast topparna saknas inte när tättrion från norska Kriteriet förra året på nytt möts. Vinnaren <strong>Nadal B.R.</strong> (e. Googoo Gaagaa), tvåan <strong>Timestile R.</strong> (e. Readly Express) och Öystein Tjomslands-tränade och svenskägde trean <strong>Felix Halbak</strong> (e. Orlando Vici). <br>Timestile R. – i år i Frode Hamres regi – har imponerat mest 2025 med tre raka segrar och vann på Bjerke för drygt tre veckor sedan när trion möttes senast. Han och Felix Halbak dyker upp i samma försök.</p>



<p>Finalen körs med ett förstapris på 300.000 norska kronor.</p>



<p>Stoavdelningens final avgörs på lördag och på söndag avslutas Jarlsbergs trippeltrav med toppnumret Ulf Thoresen Grand International – <a href="https://sulkysport.se/dukat-for-repris-for-onas-prince/" target="_blank" rel="noreferrer noopener">läs mer här!</a></p>



<p><a href="https://www.travsport.no/travbaner/jarlsberg-travbane/startlist/2025-07-04" target="_blank" rel="noreferrer noopener">Här är startlistorna till Jarlsbergs fredagstävlingar.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Storloppshästar i lägre klass
Vassa avdelningar av Margaretas Tidiga Unghästserie. Malmins dom efter Åby Stora. Försök och final i Lycksele. Tio av tolv till final i norska Sprintermästaren.
Detta och mer bland morgonens nyheter.
Detta och mer bland morgonens nyheter.
