
<p class="has-drop-cap wp-block-paragraph">1 Vintermeetingets största stjärna – ursäkta Prix d’Amérique-vinnaren <strong>Hooker Berry</strong>! – gör comeback på lördag och <strong>Ampia Mede Sm </strong>(e. Ganymede) startar i Prix Chambon P (€120.000) på Vincennes.</p>



<p class="wp-block-paragraph">Ampia Mede Sm slutade tvåa i Prix d’Amérique, men vann både Prix de France (€400.000) och Prix de Paris (€400.000) och blev vintermeetingets mestvinnande travare med 666.100 intjänade euro.</p>



<p class="wp-block-paragraph">I samma lopp årsdebuterar också fjolårets vinnare av Harper Hanovers lopp – <strong>Diable de Vauvert</strong> (e. Prince d’Espace) – vilken gör sin första start sedan 17 augusti ifjol och då han slutade fyra i Prix Jean-Luc Lagardere på Enghien.</p>



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



<p class="wp-block-paragraph"><strong>Prix Chambon P</strong> (€120.000)<br>Sex-tio år.<br><em>2.850 meter.</em></p>



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



<ol class="wp-block-list">
<li><strong>Giboulee de Mars</strong> (e. Orlando Vici) – Frederic Senet</li>



<li><strong>Harlem de Bucy</strong> (e. Lilium Madrik) – Alexandre Abrivard</li>



<li><strong>Fine Perle of Love </strong>(e. Theo Josselyn) – Matthieu Abrivard</li>



<li><strong>Hokkaido Jiel </strong>(e. Brillantissime) – David Thomain</li>



<li><strong>Gently de Muze </strong>(e. Perlando) – Jean-Michel Bazire</li>



<li><strong>Fakir du Lorault</strong> (e. Vaillant Cash) – Eric Raffin</li>



<li><strong>Elvis du Vallon</strong> (e. Reve de Beylev) – Yoann Lebourgeois</li>



<li><strong>Diable de Vauvert</strong> (e. Prince d’Espace) – Bertrand le Beller</li>



<li><strong>Ampia Mede Sm </strong>(e. Ganymede) – Franck Nivard</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">2 Summer Meeting är ett samarbete i olika klasser och löpningsserier i tre länder mellan svenska banorna Halmstad, Jägersro och Åby samt Bjerke och Charlottenlund. På torsdagens svenska huvudbana <strong>Åby</strong> (första start 18.20) avgörs försök i två av klasserna.</p>



<p class="wp-block-paragraph">Det handlar om Summer Meeting Mares med final på Jägersro på Åbergskvällen den 25 juli och Summer Meeting Halmstad, vars final körs på Sprintermästarkvällen den 6 juli. Båda finalerna har 100.000 kronor i förstapris.</p>



<p class="wp-block-paragraph">De två främsta i försöken är skyldiga att starta i finalen. Flera spännande namn dyker upp i kvällens stoförsök. Som Christoffer Erikssons segervana <strong>Organzza</strong> (e. S.J.’s Caviar) och Stefan P Petterssons <strong>Jest </strong>(e. Trixton). Den andra klassen är öppen för hästar med högst 700.000 kronor på kontot och flerfaldige Elitloppsdeltagaren Vivid Wise As lillebror <strong>Crown Wise As</strong> (e. Muscle Hill) ska försöka kliva runt motståndarna från bakspår.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/09/donizetti-617x333.jpg" alt="" class="wp-image-211534"/><figcaption class="wp-element-caption">Donizetti vinner från dödens för Kevin Oscarsson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Torsdagens mest spännande lopp på förhand ser annars ut att vara en spårtrappa för hästar med högst 1.575.000 kronor på kontot och rikast i fältet är Jerry Riordans femåring <strong>Donizetti </strong>(e. Maharajah) med finalplatser i Derbyt (femma i finalen), Kriteriet, Breeders Crown och E3 på meritlistan. Nu är han åter ute över lång distans i jakten på första årssegern med ett lopp i kroppen efter några månaders uppehåll.</p>



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



<p class="has-drop-cap wp-block-paragraph">3 På <strong>Bergsåker</strong> (start 17.45) debuterar Robert Bergh en spännande treåring i <strong>Ferrara </strong>(e. Readly Express). Hästen är sista avkomman till Elitstoet <strong>Big Blue Kitten</strong> och är resultatet av ett embryotransfer, då han föddes året efter moderns död.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/skarmavbild20230607kl.16.07.13-617x490.jpg" alt="" class="wp-image-455122"/><figcaption class="wp-element-caption">Ferrara när hästen såldes på Menhammar Online Sales. Foto: Menhammar Online Sales</figcaption></figure>



<p class="wp-block-paragraph">Robert Bergh ropade in hingsten för 525.000 kronor på Menhammar Online Sales sommaren 2021 för In the Zone AB:s räkning och Ferrara är lillebror till avelshingstarna <strong>Yarrah Boko</strong> (e. Coktail Jet), 1.09,7ak*/11.173.712 kr, och <strong>Zola Boko</strong> (e. Goetmals Wood), 1.11,6am*/1.950.214 kr. I debuten ställs Ferrara bland annat mot Daniel Wäjerstens duo <strong>Global Escape </strong>(e. S.J.’s Caviar) och <strong>Staro Litchi</strong> (e. Father Patrick), som vunnit varsitt lopp och startar 20 meter bakom debutanten.</p>



<p class="wp-block-paragraph">En talang som redan visat upp sig på banan med fläckfritt resultat är Henrik Hoffmans treåring <strong>Young Yack</strong> (e. Nuncio), som inlett tävlingskarriären med tre raka segrar på hemmaplan. En fjärde kan komma redan ikväll i <strong>Visby</strong> (start 17.40), där Young Yack ställs mot äldre hästar och brottas med femtespår i volten och 20 meters tillägg.</p>



<p class="wp-block-paragraph">Lunchbanan<strong> Bollnäs</strong> (start 12.20) har breddlopp på menyn.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/06/230608.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till torsdagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 På fredag avgörs det andra Grupp I-loppet för treåringar på italiensk mark i år och det handlar om Gran Premio Nazionale (€154.000) över 2.250 meter.</p>



<p class="wp-block-paragraph"><strong>Ector Francis</strong> (e. Nad al Sheba) vann Gran Premio Tito Giovanardi (€154.000) och han finns också med i Milano.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/skarmavbild20230514kl.16.45.54-617x321.jpg" alt="" class="wp-image-443770"/><figcaption class="wp-element-caption">Ector Francis och Gaetano di Nardo vinner Gran Premio Tito Giovanardi. </figcaption></figure>



<p class="wp-block-paragraph">Stona tävlar i Grupp II-loppet Gran Premio Nazionale Filly (€66.000) över 1.650 meter och även vinnaren från Gran Premio Carlo Cacciari (€66.000) – <strong>Elettra d’Esi </strong>(e. Nad al Sheba) – dyker upp på La Maura-banan.</p>



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



<p class="wp-block-paragraph"><strong>Gran Premio Nazionale </strong>(€154.000)<br>Treåringar.<br><em>2.250 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Ete Jet </strong>(e. Maharajah) – Vincenzo P. Dell’Annunziata</li>



<li><strong>Eminem Font</strong> (e. Ringostarr Treb) – Marco Stefani</li>



<li><strong>East Asia </strong>(e. Ready Cash) – Andrea Farolfi</li>



<li><strong>Energy King Gar</strong> (e. Wishing Stone) – Antonio Simioli</li>



<li><strong>Elton Wise </strong>(e. Maharajah) – Alessandro Gocciadoro</li>



<li><strong>Edy Girifalco Gio</strong> (e. Victor Gio) – Santo Mollo</li>



<li><strong>Ector Francis</strong> (e. Nad al Sheba) – Gaetano di Nardo</li>



<li><strong>Ettore Trebi</strong> (e. Nad al Sheba) – Antonio Greppi</li>



<li><strong>Elleboro Dr</strong> (e. Oasis Bi) – Pietro Gubellini</li>



<li><strong>Encierro</strong> (e. Tobin Kronos) – Gaspare Lo Verde</li>



<li><strong>Enea Sl</strong> (e. Bar Hopping) – Antonio di Nardo</li>



<li><strong>Etereo Jet</strong> (e. Igor Font) – Edoardo Baldi</li>



<li><strong>Ernesto Roc</strong> (e. Face Time Bourbon) – Filippo Rocca</li>



<li><strong>Ela Linda</strong> (e. Royal Blessed) – Enrico Bellei</li>
</ol>



<p class="wp-block-paragraph"><strong>Gran Premio Nazionale Filly</strong> (€66.000)<br>Treåriga ston.<br><em>1.650 meter, autostart.</em></p>



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



<p class="wp-block-paragraph"><strong>Eclisse Roc</strong> (e. Iper Roc) – Santo Mollo<br><strong>Eva Kant Gio</strong> (e. Vivid Wise As) – Alessandro Gocciadoro<br><strong>Emah Roc </strong>(e. Conway Hall) – Filippo Rocca<br><strong>Esedomani</strong> (e. Nad al Sheba) – Marco Smorgon<br><strong>Elettra d’Esi </strong>(e. Nad al Sheba) – Edoardo Baldi<br><strong>Eleganza Av</strong> (e. Espoir Prestance) – Manuel Pistone<br><strong>El Alamein</strong> (e. Robert Bi) – Andrea Farolfi<br><strong>Eiffel Fi</strong> (e. Exploit Caf) – Antonio Simioli<br><strong>Eletta Star</strong> (e. Napoleon Bar) – Gaetano di Nardo<br><strong>Euphoria Bi </strong>(e. Donato Hanover) – Mario Biasuzzi<br><strong>Elenoire Rab</strong> (e. The Lindy Reserve) – Tommaso Gambino<br><strong>Ekarin Baba</strong> (e. Oasis Bi) – Pietro Gubellini<br><strong>Emma dei Veltri </strong>(e. Maharajah) – Vincenzo P. Dell’Annunziata<br><strong>Estasi di No</strong> (e. Nad al Sheba) – Marco Stefani</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Svensktränade eller svenskfödda hästar lyser med sin frånvaro på fransk mark denna torsdag, men det finns andra spännande springare som kommer till start.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/09/criterium4ans1-617x393.jpg" alt="" class="wp-image-208672"/><figcaption class="wp-element-caption">Hastrounate (2) vid vinsten i Criterium des 4 ans för Matthieu Abrivard. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">I <strong>Toulouse </strong>(första start 18.17) jagar 2021 års Criterium des 4 ans-vinnare <strong>Hastronaute </strong>(e. Booster Winner) sin andra raka seger efter att gått segerlös sju starter i följd.</p>



<p class="wp-block-paragraph">Efter Grupp I-skrällen som fyraåring har Hastronaute haft förtvivlat svårt att leverera, men i just Toulouse visade han klar uppryckning vid seger den 19 maj och ikväll ser den av Yannick Henry-tränade hästen ut att bli favorit i Grand Prix du Capitole (€53.000) över 2.950 meter voltstart där vinnaren belönas med 23.850 euro.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 På lördag bjuds det på två penningstinna fyraåringslopp på Victoria Park i Wolvega och då avgörs TCT Derby (€55.000) i den öppna klassen, medan stona tävlar om 33.000 euro i totalprissumma.</p>



<p class="wp-block-paragraph">I fem starter obesegrade <strong>Yesterday Diamant</strong> (e. Gustav Diamant), 1.13,9al*/€17.000, vilken tidigare tidigare tagit sin största seger i treåringsloppet Halali (€20.000) i Hamburg har de flesta blickarna riktade mot sig.</p>



<p class="wp-block-paragraph">I stonas uppgörelse årsdebuterar <strong>Look of Love </strong>(e. Ready Cash), 1.12,6ak/€53.836, och ifjol tog hon hem Tyskt Breeders Crown (€28.495) i Berlin för Jean-Pierre Dubois. På fredag tar Piet van Pollaert hand om tömmarna för första gången.</p>



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



<p class="wp-block-paragraph"><strong>TCT Derby</strong> (€55.000)<br>Fyraåringar.<br><em>2.600 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Y Not Diamant </strong>(e. Odessa Santana) – Robin Bakker</li>



<li><strong>Yesterday Diamant </strong>(e. Gustav Diamant) – Jaap van Rijn</li>



<li><strong>Mystical Spell </strong>(e. Maharajah) – Danny Brouwer</li>



<li><strong>Hurricane</strong> (e. Father Patrick) – Micha Brouwer</li>



<li><strong>Jos Maza</strong> (e. Bird Parker) – Michel Rothengatter</li>



<li><strong>Yahoo Diamant</strong> (e. Indigious) – Michael Nimczyk</li>



<li><strong>Mireije Charisma</strong> (e. Chelsea Boko) – Danny den Dubbelden</li>



<li><strong>Mr T Starlake</strong> (e. From Above) – Rob de Vlieger</li>



<li><strong>Costello O.E.</strong> (e. Bold Eagle) – Jules Van den Putte Jr.</li>



<li><strong>Most Wanted PK</strong> (e. Formula One) – John Dekker</li>
</ol>



<p class="wp-block-paragraph"><strong>TCT Filly Derby</strong> (€33.000)<br>Fyraåriga ston.<br><em>2.100 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Maverick</strong> (e. Virgill Boko) – Tom Kooyman</li>



<li><strong>Julia Sisu </strong>(e. Kadabra) – Michael Nimczyk</li>



<li><strong>Look of Love</strong> (e. Ready Cash) – Piet van Pollaert</li>



<li><strong>Jamaica Brown</strong> (e. Vramdao) – Jeffrey Mieras</li>



<li><strong>Bella Bavaria </strong>(e. Gustav Diamant) – Robin Bakker</li>



<li><strong>Metta Invicta</strong> (e. Creatine) – struken</li>



<li><strong>Malou Vredebest</strong> (e. Yeovani Boko) – Jaap van Rijn</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">7 I söndags på Haras de la Cour i Moyon blev <strong>Shafina Hanover</strong> (e. Explosive Matter-She’s A Blizzard), 1.11,5ak/650.584 kr, mor till en dotter efter Campo Bahia.</p>



<p class="wp-block-paragraph">– Hon går till Django Riff, berättar Tobias Nilsson.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/shafinahanover-350x568.jpeg" alt="" class="wp-image-455104"/><figcaption class="wp-element-caption">Shafina Hanovers dotter efter Campo Bahia. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Shafina Hanover fick sin sjunde avkomma, varav två av tre startande avkommor vunnit lopp; <strong>Global Boom</strong> (e. S.J.’s Caviar), 1.14,3am*/172.000 kr, och <strong>Global Delicious</strong> (e. Bold Eagle), 1.16,3am/33.300 kr.</p>



<p class="wp-block-paragraph">Modern Shafina Hanover är undan <strong>She’s A Blizzard </strong>(e. Malabar Man), 1.13,0*/$123.185, vars främsta avkommor är <strong>Mymomsablizzard </strong>($480.909), och <strong>Star Track Hanover </strong>($164.498). </p>



<p class="wp-block-paragraph">Själv är She’s A Blizzard mormor till Kentucky Futurity-vinnaren <strong>Snowstorm Hanover </strong>(e. Muscle Massive), 1.09,8ak/7.439.720 kr.</p>



<p class="wp-block-paragraph">Årets sista föl kan Stall Rohero räkna in. <strong>Spurt Engine</strong> (e. Scarlet Knight-Elma Jet), 1.14,9ak/87.300 kr, har nedkommit med ett sto efter Readly Express.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/06/resized20230607144334.jpg" alt="" class="wp-image-455106"/><figcaption class="wp-element-caption">Spurt Engine med sin dotter efter Readly Express. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">– Nästa partner blir Cash Gamble, berättar Robin Thörn, som också kan meddela att Stall Rohero kan glädja sig åt åtta föl:</p>



<p class="wp-block-paragraph">– De tre första var hingstar och sedan har det blivit fem raka ston.</p>



<p class="wp-block-paragraph">Samtliga fyra avkommor undan Spurt Engine har visat sig på tävlingsbanan och bäst har det gått för duon <strong>Silver Bullit</strong> (e. Orlando Vici), 1.11,9am/766.700 kr, och <strong>The Engine</strong> (e. The Bank), 1.12,6ak/437.300 kr.</p>



<p class="wp-block-paragraph">Mor har också <strong>Classy Credit </strong>(e. Credit Winner-Classical Movenment), 1.13,4ak/181.337 kr, blivit till ett sto efter Face Time Bourbon.</p>



<p class="wp-block-paragraph">– Hon går till Father Patrick, berättar Björn Arvenberg.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/classycredit-617x463.jpg" alt="" class="wp-image-455107"/><figcaption class="wp-element-caption">Classy Credits dotter efter Face Time Bourbon. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Classy Credit har tre avkommor i startbar ålder och alla har varit ute och startat; <strong>Classy Knox</strong> (e. Uncle Lasse), 1.12,0ak/456.650 kr, <strong>Shorttriptonice</strong> (e. S.J.’s Caviar), 1.13,4am/189.453 kr, och till Finland exporterade <strong>Austin </strong>(e. Brad de Veluwe), 1.15,0am/100.800 kr.</p>



<p class="wp-block-paragraph">Mormor <strong>Classical Movement </strong>(e. Malabar Man), 1.16,1*, är undan <strong>Classical Motion </strong>(e. Crowning Point), 1.13,1/$33.187, som är helsyster med storstjärnan Crowning Classic, 1.11,6/€1.621.879, vilken bland annat vann dubbla upplagor av Campionato Europeo, Gran Premio della Lotteria, Gran Premio delle Nazioni och försök i Elitloppet.</p>



<p class="wp-block-paragraph">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.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>
