
<p class="has-drop-cap wp-block-paragraph">1 Hela 250.000 kronor erbjuds det i förstapris i Åby Monté Trophy ikväll på <strong>Åby</strong> (första start 18.20) och det har samlat ett fint sällskap sadelspecialister. Eller vad sägs om tätduon från Montéeliten plus de senaste två årens vinnare av Åby Monté Trophy?</p>



<p class="wp-block-paragraph">På Solvalla drog franska stoet <strong>Kerry Love </strong>(e. Brillantissime) längsta strået tillsammans med Sveriges ryttarchampion de senaste säsongerna Jonathan Carré. Då tränades hästen av Mathieu Mottier, men efter Solvallatriumfen stannade hon hos Jonathan och sambon Constanza Flores för att tävla vidare på nordisk mark. Efter galopp i ett sulkyframträdande i regidebuten är hon tillbaka under sadel.</p>



<p class="wp-block-paragraph">Då ska hon på nytt försöka besegrade norsktränade segermaskinen <strong>First One Diamond </strong>(e. Ens Snapshot), som slutade tvåa på Solvalla tillsammans med Kristine Kvasnes.</p>



<p class="wp-block-paragraph">Även bronsmedaljören från Montéeliten finns med ikväll. 13-årige <strong>Corps et Ame</strong> (e. Jag de Bellouet) som vunnit Åby Monté Trophy två är i rad! Ifjol satt en viss Carré i sadeln när denne tog sin första ryttarinteckning i loppet.</p>



<h2 class="wp-block-heading">Tidigare vinnare av Åby Monté Trophy</h2>



<p class="wp-block-paragraph"><strong>År – Namn – Ryttare – Segertid</strong></p>



<ul class="wp-block-list">
<li>2018 – <strong>Be Mine de Houelle</strong> – Marie Bacsich – 1.12,4a</li>



<li>2019 – <strong>Ladyofthelake</strong> – Anna Erixon – 1.13,2a</li>



<li>2020 – <strong>Hambo Transs R.</strong> – Michelle Mönster – 1.12,2a</li>



<li>2021 – <strong>Mindyourvalue W.F. </strong>– Emilia Leo – 1.11,8a</li>



<li>2022 – <strong>Mindyourvalue W.F.</strong> – Christina A Hande – 1.12,3a</li>



<li>2023 – <strong>Corps et Ame</strong> – Louis Jublot – 1.11,4a</li>



<li>2024 – <strong>Corps et Ame</strong> – Jonathan Carré – 1.12,3a</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">2 Åby bjuder på en toppkväll och lärlingarna får chansen att tävla om 125.000 kronor i förstapris i Olle Elfstrand Trophy för kuskar födda 1994 eller senare. Loppet avgörs för tredje gången och de tidigare vinnarna är Max Karlsson bakom <strong>Captor Delleselve</strong> och ifjol Linus Lönn med <strong>Chanel Trio</strong>.</p>



<p class="wp-block-paragraph">Olle Elfstrand har skänkt en vandringspokal som ska tas hem två gånger av samme körsven. Både Max och Linus saknas dock i årets upplaga.</p>



<p class="wp-block-paragraph">Olle Elfstrand förknippas allra mest med <strong>Lyon</strong> – Sveriges första travare som tjänade över en miljon kronor och dessutom blev vald till ”Årets Häst” vid tre olika tillfällen. Åren 1969, 1970 och 1972.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/02/lyonmal-617x333.jpg" alt="" class="wp-image-141052"/><figcaption class="wp-element-caption">Lyon och Olle Elfstrand vann Elitloppsförsök 1972. Foto Lars-Erik Lundqvist/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Totalt har Olle över 2.000 segrar som kusk, men även om han var uppväxt vid 200-meterspålen vid Färjestads travbana fast på andra sidan Klarälven var det ändå inte givet att travet skulle bli hans framtid. Till travbanan hittade Olle Elfstrand tidigt och vid 23 års ålder plockade han ut sin proffslicens efter att ha arbetat som lärling hos Uno Swed. Olle Elfstrand avslutade tränarkarriären vid årsskiftet och körde sitt sista lopp 2020.</p>



<p class="wp-block-paragraph">Det bjuds fina tävlingar överlag på Åby och i ett vanligt lopp stängt vid 37.000 kronor dyker Sveriges näst snabbaste, treårige debutvinnare genom tiderna upp. André Eklundh-tränade <strong>Maverick K.W.</strong> (e. Cristal Money) debutvann på 1.14,4a/2.140 meter på Färjestad för drygt två veckor sedan och bara blivande Kriterievinnaren <strong>Inti Boko</strong> (e. Chocolatier) har varit snabbare över medeldistans i debuten som treåring. Han travade 1.14,2a för sju år sedan. </p>



<p class="wp-block-paragraph">En annan treåring som utmärkt sig i början av karriären är Robert Bergh-tränade <strong>Valla d’Gaagaa</strong> (e. Googoo Gaagaa), som är obesegrad i tre starter inför kvällen start.</p>



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



<p class="has-drop-cap wp-block-paragraph">3 Ytterligare två svenska banor tävlar idag och på <strong>Solänget</strong> (start 12.20) ser det ut att bli ett klubbmästerskap mellan tre hästar från Jan-Olov Perssons stall. <strong>Prinsessan Stöen</strong> (e. Bork Odin) har redan vunnit fem lopp under 2025 och kommer från en fin insats som tvåa bakom <strong>Tekno Tana </strong>(e. Art Kjarvald) på vassa 1.22,1a/1.640 meter hemma på Hagmyren på midsommarafton.</p>



<p class="wp-block-paragraph">Nu ska hon försöka hålla undan 20 meter för stallkamraterna <strong>Hulte Sixten</strong> (e. Horgen Tore) och <strong>Rams Bror</strong> (e. Ramstad Eld), som båda kommer från vinst i sina senaste starter.</p>



<p class="wp-block-paragraph"><strong>Örebro</strong> (start 17.45) är saxbana ikväll och en bred delningsproposition med spårtrappor – 20.001-1.300.000 kronor – har samlat spännande namn i olika lopp. Bland annat gör Oskar J Anderssons rikstotohärdade <strong>Sultan Sea</strong> (e. Maharajah) comeback efter nästan elva månaders tävlingsfrånvaro. En seger och tre andraplatser blev det på åtta STL-starter innan uppehållet.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/06/250626.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/06/250626.pdf" 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">4 Sexåriga <strong>Bikana Wine</strong> (e. Propulsion-Kimono Pearl), 1.12,0ak/730.400 kr, återvänder till sin uppfödare Peter ”Vinum Stables” Martinsson och har gjort sitt sista tävlingsframträdande den 16 juni i Halmstad.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/02/bikanawinejum230204adamstromstalltz-scaled.jpg" alt="" class="wp-image-407373"/><figcaption class="wp-element-caption">Bikana Wine vid segern i Margaretas Tidiga Unghästserie. Foto Adam Ström/stlltz.se</figcaption></figure>



<p class="wp-block-paragraph">– Jag har köpt tillbaka Bikana Wine för avel. Det är för sent att betäcka henne i år, men troligen blir det Face Time Bourbon nästa år, säger Peter Martinsson.</p>



<p class="wp-block-paragraph">Bikana Wine har tävlat för Johan Untersteiner och Gustav Johansson och totalt gjorde hon 29 starter (6-1-2) och största segern togs som fyraåring i Margaretas Tidiga Unghästserie – värderad till 300.000 kronor – på Solvalla.</p>



<p class="wp-block-paragraph">Bikana Wine är undan <strong>Kimono Pearl </strong>(e. Super Arnie), 1.11,6ak*/879.554 kr, och ingår i samma syskonskara som <strong>Rio Alta Wine</strong> (e. Readly Express), 1.12,7am/914.700 kr.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Två svenskfödda travare dyker upp i det högst doterade loppet på <strong>Enghien </strong>(första start kl. 11.16) idag och det handlar om Stefan Arvidssons G.K. Justus (e. Brad de Veluwe) och Jörgen Westholms Made of Stars (e. Super Photo Kosmos).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/02/00266222042scoopdyga-617x411.jpg" alt="" class="wp-image-683768"/><figcaption class="wp-element-caption">Stefan Arvidssons G.K. Justus vid vinst på Vincennes. Foto: Scoopdyga</figcaption></figure>



<p class="wp-block-paragraph">Sadelloppet Prix de la Place Chopin (€54.000) är ett lärlingslopp över 2.875 meter och lockar med ett förstapris på 24.300 euro. Cléa Roger rider G.K. Justus och Mehdi Lelievre tar hand om Made of Stars.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 I söndags vann Prix d’Amérique-vinnaren <strong>Belina Josselyns </strong>förstfödda dotter <strong>Liza Josselyn </strong>(e. Ready Cash) Grupp III-loppet Prix Raymond Fouard (€80.000) på Vincennes.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2017/02/belinajosselyn-617x334.jpg" alt="Belina Josselyn och Jean Michel Bazire i värmningen inför Prix d'Amérique. Foto Mia Törnberg" class="wp-image-1746"/><figcaption class="wp-element-caption">Belina Josselyn. Foto Mia Törnberg</figcaption></figure>



<p class="wp-block-paragraph">Några veckor tidigare nedkom modern Belina Josselyn (e. Love You), 1.10,2am*/€2.686.170, med ett sto efter Idao de Tillard. Årets partner är utsedd till Jushua Tree.</p>



<p class="wp-block-paragraph">Belina Josselyns första fyra avkommor är fallna efter Ready Cash och förutom Liza Josselyn, 1.10,7m*/€365.900, har också <strong>Mythique Josselyn</strong>, startat, tjänat 1.750 euro och varit trea som bäst på tre starter.</p>



<p class="wp-block-paragraph">Förra året såldes hennes då ettåriga dotter <strong>Nodessa Josselyn</strong> för 740.000 euro på Arqana Trot-auktion i Deauville och hon är den dyraste ettåringen som sålts i Europa. Steve Farrugia – hästägare hos Vincent Martens – köpte Ready Cash-dottern.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Anrika Gran Premio d’Europa – sedan några år omdöpt till Gran Premio Unione Europea (€154.000) – avgörs i Modena på lördag. Fyraåringsloppet går över medeldistans och flera italienska topptravare dyker upp.</p>



<p class="wp-block-paragraph">Under många år var Gran Premio d’Europa ett stående inslag för svenskfödda travare – senaste vinnaren var <strong>Kramer Boy </strong>(e. Sugarcane Hanover) och Johnny Takter och då får vi vrida klockan tillbaka till 1997. Enda utländska inslaget i årets Grupp I-lopp är tyskfödde Maharajah-sonen <strong>Carpendale</strong>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/04/derby4annimaschianact1-617x393.jpg" alt="" class="wp-image-703404"/><figcaption class="wp-element-caption">First of Mind och Alessandro Gocciadoro jagar sin tredje Grupp I-vinst i år på lördag. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Alessandro Gocciadoro sitter upp bakom <strong>First of Mind </strong>(e. Face Time Bourbon) och jagar fjärde raka segern efter tidigare i år vunnit försök och final i Anact Stakes Plus+ (€200.200) och Gran Premio Tino Triossi (€154.000).</p>



<p class="wp-block-paragraph">Motståndet kommer i första hand från en annan Face Time Bourbon-son. <strong>Frank Gio</strong> har vunnit Grupp I-klassade Prix Ourasi (€300.000) och semi-classique-löpningen Prix Charles Tiercelin (€120.000) på Vincennes.</p>



<p class="wp-block-paragraph"><strong>Gran Premio Unione Europea</strong> (€154.000)<br>Fyraåringar.<br><em>2.080 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>First of Mind</strong> (e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li><strong>Falco Killer Gar</strong> (e. Varenne) – Antonio Di Nardo</li>



<li><strong>Funky Roc </strong>(e. Nad al Sheba) – Santo Mollo</li>



<li><strong>Frank Gio</strong> (e. Face Time Bourbon) – Matthieu Abrivard</li>



<li><strong>Fortunadrago Font</strong> (e. Quite Easy) – Carmine Piscuoglio</li>



<li><strong>Fil Ek </strong>(e. Ringostarr Treb) – Pietro Gubellini</li>



<li><strong>Far West Bi</strong> (e. Muscle Hill) – Roberto Vecchione</li>



<li><strong>Carpendale</strong> (e. Maharajah) – Christoph Schwarz</li>



<li><strong>Frankie LJ</strong> (e. Readly Express) – Massimiliano Castaldo</li>



<li><strong>Fakir Roc</strong> (e. Wishing Stone) – Vincenzo Piscuoglio dell&#8217;Annunziata</li>
</ol>
