
<p class="has-drop-cap">1 Söndagen den 23 juni bjuder Vincennes på en tävlingsdag utöver det vanliga med fem Grupp I-löpningar och sedan serveras publiken mat av av absolut toppklass på den franska huvudstadsovalen.</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/06/skarmavbild20240612kl.10.44.06.jpg" alt="" class="wp-image-595726"/></figure>



<p>Fransk gastronomi kommer också stå i fokus på Vincennes. Justine Piluso, en av stjärnkockarna i Top Chef 2020, kommer finnas vid ringside och låter besökarna testa smaklökarna från hennes egenkomponerade ”finger food”.</p>



<p>En dessert kommer också att specialkomponeras dagen till ära av Nicolas Paciello. Han är en av de stora namnen inom franskt konditori och var finalist i Meilleur Ouvrier de France.</p>



<p>Vid sidan av banan kommer franska street food-mästare som Bokit och Mobile Burger, båda medaljvinnare, att servera läckra specialiteter.</p>



<h2 class="wp-block-heading">Här är Grupp I-loppen som avgörs på Vincennes:</h2>



<ul class="wp-block-list">
<li><strong>Prix President Republique </strong>(4 år, monté) – €240.000</li>



<li><strong>Prix de Normandie</strong> (5 år, monté) – €240.000</li>



<li><strong>Prix d’Essai</strong> (3 år, monté) – €200.000</li>



<li><strong>Prix René Ballière </strong>(4-11 år) – €200.000</li>



<li><strong>Prix Albert Viel</strong> (3 år) – €200.000</li>
</ul>



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



<p class="has-drop-cap">2 Summer Meeting är ett samarbete mellan Åby, Jägersro, Halmstad, Charlottenlund och Bjerke med flera olika klasser, där försöks kör på varje bana och sedan delar banorna på finalerna. Totalt är det åtta finaler i år och den första finalen vanns på Bjerke i söndags av Frode Hamres <strong>Extreme Point</strong> (e. Espoir Prestance).</p>



<p>På kvällens huvudbana <strong>Åby</strong> (första start 18.20) blir det ikväll försök till två av klasserna, där försöket för hästar med högst 700.000 kronor insprunget sticker ut lite extra. Finalen avgörs på Halmstads Sprintermästarkväll och de svensktränade hästarna får tuffa nötter att knäcka för att knipa någon av de två finalplatserna.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/flemmingjensen-617x333.jpg" alt="" class="wp-image-523523"/><figcaption class="wp-element-caption">Flemming Jensen. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Från Danmark kommer Flemming Jensen med årsdebutanten <strong>Game On Butcher</strong> (e. Stand and Deliver), som avslutade fjolåret med klass I-seger på Jägersro innan han tvingades strykas för hälta från annandagen på Solvalla.</p>



<p>Norge rustar med Thor Borg-tränade <strong>Wishful Order </strong>(e. Muscle Hill). Denne kvalade in till klass I-finalen under Elitloppshelgen via seger på Åby i april och kommer närmast från spetsseger i damloppet Kronprinsessan Victorias lopp på Axevalla tillsammans med Kajsa Frick.</p>



<p>I övrigt på Åby då? Italienaren Gennaro Casillo, med filial i Sverige, spände bågen med segervane <strong>Cosmico Polare</strong> (e. Royal Blessed), som slutade sjua i Harper Hanovers lopp i första starten på svensk mark. Hästen har redan vunnit sju lopp i år (i Italien). Nu varvar han ner ordentligt motståndsmässigt när han kommer ut i lärlings- och amatörlopp med tränarsonen Manuele Casillo i sulkyn. Och Manuele har koll på hästen – som delägare och kusk med flera segrar från italiensk mark bakom hästen.</p>



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



<p class="has-drop-cap">3 Torsdagen inleds med lunchtävlingar i <strong>Örebro</strong> (start 12.20), där en spårtrappa över lång distans med 14 hästar bakom bilen ser spännande ut på förhand. Det ryms nämligen en hel del STL-kändisar bland deltagarna.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/09/claessjostrom2-617x333.jpg" alt="" class="wp-image-219579"/><figcaption class="wp-element-caption">Claes Sjöström. Foto: Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Claes Sjöström plockar ut <strong>Mahadour </strong>(e. Maharajah) i årsdebut och första starten på tio månader efter skadeuppehåll och en fyramånadersperiod hos Caroline Holm under rehabiliteringen. </p>



<p>Förre Eskilstunaproffset Håkan ”Hockey” Erikson är uppfödare och delägare i femåringen som efter att ha varit segerlös i sju starter som treåring blomstrade rejält förra året. Nio starter gav fyra segrar och bara två gånger missade han pallen. Bland annat var Mahadour etta-tvåa i klass II-försök och segern kom just över dagens förutsättningar: lång distans och startbil.</p>



<p>Bland motståndarna finns <strong>Ever Loving </strong>(e. Muscle Hill) som gjorde tre raka rikstotostarter i vintras i Öystein Tjomslands regi med en tredjeplats som bästa resultat. Nu debuterar han för Andreas Lövdal.</p>



<p>Kvällen kompletteras med breddlopp i <strong>Rättvik</strong> (start 17.45), där en av landets 14-åringar på tävlingsbanorna dyker upp. Det handlar om Ante Lisells <strong>Super Zantos</strong> (e. Mythical Lindy), som sprungit in nästan 2,6 miljoner kronor hittills i karriären. Senaste segern ligger dock långt tillbaka i tiden, Romme den 21 februari 2020, eller 96 starter. Läge att bryta sviten på hemmaplan?</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/06/240613.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 Sedan tyska travförbundet valde att byta ålder för Derbyt körs sedan 2022 Kriterium för treåringar, uppdelat i två olika klasser. På söndag hålls den tredje försöksrundan i München. Där dyker bland annat i två starter obesegrade Googoo Gaagaa-dottern <strong>Sahara Firebird</strong> upp.</p>



<p>Hon har vunnit sina båda försök i Dreijährigen Kriterium och i debuten travade hon 1.14,3a/2.000 meter för Michael Nimczyk.</p>



<p>Ingen av de tidigare försöksvinnarna bland de manliga deltagarna finns med på söndag på Daglfing-banan. <strong>Ready Hill</strong> (e. Muscle Hill) har varit tvåa och fyra i de tidigare starterna i försöken i Dreijährigen Kriterium och jagar sin första seger.</p>



<h2 class="wp-block-heading">Startlistor:</h2>



<p><strong>Dreijährigen Kriterium </strong>(€7.000)<br>Treåriga hingstar/valacker.<br><em>2.100 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Carpendale </strong>(e. Maharajah) – Christoph Schwarz</li>



<li><strong>Foreman</strong> (e. Face Time Bourbon) – Rudolf Haller</li>



<li><strong>Ready Hill</strong> (e. Ready Cash) – Michael Nimczyk</li>



<li><strong>Summermusic’night S</strong> (e. Tactical Landing) – Jos Verbeeck</li>



<li><strong>Global Player S</strong> (e. E L Titan) – Jouni Nummi</li>



<li><strong>Utility Man </strong>(e. Partout Simoni) – Joseph Sparber</li>
</ol>



<p><strong>Dreijährigen Kriterium </strong>(€7.000)<br>Treåriga ston.<br><em>2.100 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Spice Girl S </strong>(e. Tactical Landing) – Jouni Nummi</li>



<li><strong>Beauty Jumeirah </strong>(e. Owen C.R.) – Matthias Schambeck</li>



<li><strong>Princess Peach</strong> (e. Spartan Kronos) – Rudolf Haller</li>



<li><strong>Belina Times</strong> (e. Indigious) – Christoph Schwarz</li>



<li><strong>Sway S</strong> (e. Tactical Landing) – Andreas Geineder</li>



<li><strong>Sahara Firebird</strong> (e. Googoo Gaagaa) – Michael Nimczyk</li>



<li><strong>Ultrablue </strong>(e. Orlando Vici) – Herbert Strohl</li>



<li><strong>Bumblebee S</strong> (e. Father Patrick) – Jos Verbeeck</li>
</ol>



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



<p class="has-drop-cap">5 Penningstinna fyraåringsloppet Gran Premio d’Europa (€209.000) avgörs den 28 juni i Modena och ikväll på Ippodromo Ghirlandina generalrepeterade några av topparna i 2020-kullen i Prix Isole Eolie (€12.650) över samma distans som Gran Premio d’Europa.</p>



<p>Vann i det fem hästar stora fältet gjorde <strong>Edy Girifalco Gio </strong>(e. Victor Gio-Mururoa As) och Massimiliano Castaldo efter en resa i rygg på ledande Etero Jet (e. Igor Font), vilken avfärdades kort före linjen. Båda travarna noterade 1.13,5a/2.080 meter. </p>



<p>Ifjol vann Edy Girifalco Gio Grupp I-loppet Gran Premio Nazionale och slutade tvåa i Gran Premio Orsi Mangelli. </p>



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



<p class="has-drop-cap">6 Ikväll debuterar <strong>B.A. Superhero</strong> (e. Muscle Hill), 1.09,2ak/1.885.036 dkk, på italiensk mark och detta i Alessandro Gocciadoros regi. Han sitter själv upp bakom sitt nyförvärv från Bo Westergård i Gran Premio Ivone Grassetto (€37.400) över 1.640 meter, autostart.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2022/07/basuperhero172022.jpg" alt="" class="wp-image-322497"/><figcaption class="wp-element-caption">B.A. Super Hero vid seger på Meadowlands som treåring. Foto: Lisa Photo</figcaption></figure>



<p>Förra året vann han såväl Fyraåringseliten under Copenhagen Cup-dagen som Europamatchen för fyraåringar på Bjerke. Totalt har det blivit tio vinster på 35 starter. Senaste starten – i regi Bo Westergård – var i Ålborgs Stora Prix den 16 september ifjol och där slutade han oplacerad.</p>



<p>Ikväll – klockan 22.05 – släpps storloppet iväg och första upplagan av Gran Premio Ivone Grassetto hölls 1962.</p>



<p><strong>Gran Premio Ivone Grassetto </strong>(€37.400)<br>Äldre travare.<br><em>1.640 meter, autostart.</em></p>



<p><strong>Namn – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Vincero’ Gar</strong> – Andrea Farolfi</li>



<li><strong>Cointreau </strong>– Federico Esposito</li>



<li><strong>B A Superhero</strong> – Alessandro Gocciadoro</li>



<li><strong>Altaseta Del Pino</strong> – Enrico Bellei</li>



<li><strong>Dolce Viky</strong> – Manuel Pistone</li>



<li><strong>Dali Prav</strong> – Rene’ Legati</li>
</ol>



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



<p class="has-drop-cap">7 I helgen nedkom <strong>Magical Lady </strong>(e. Kadabra), 1.11,5/$117.365, med en dotter efter Gimpanzee på Cane Run Farm. Nu återvänder hon till den trefaldige Breeders Crown-vinnaren. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/06/skarmavbild20240610kl.15.25.39-617x674.jpg" alt="" class="wp-image-596162"/><figcaption class="wp-element-caption">Magical Lady med sin dotter efter Gimpanzee. Foto: Lina Alm Racing Media</figcaption></figure>



<p>Lennart ”Srf Stable” Ågren äger och Magical Lady har två avkommor sedan tidigare som varit ute och tävlat. Treåriga <strong>Shirin</strong> (e. Chapter Seven), 1.12,5*/$50.767, har vunnit tre starter på tolv starter och ett år äldre <strong>Captain Chesley</strong> (e. Tactical Landing), 1.11,5/$33.905, är snäppet värre med fem vinster på 14 framträdanden. </p>



<p>Mormor <strong>On the Bright Side</strong> (e. Cantab Hall), 1.09,7/$270.807, tävlade framgångsrikt för Jimmy Takter och i avelsboxen har hon också lämnat <strong>Sunshine Delight</strong> ($354.847) och <strong>Ontopofthehill</strong> ($110.428). </p>



<p>Ni vet väl att ni kan maila in fölrapporter för fri publicering? Uppge mor, far och kön på fölet. Skriv också om ni bestämt vilken hingst stoet ska gå till i år och skicka gärna med en bild tagen på bredden.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>
