
<p class="wp-block-paragraph">Sébastien Guarato-tränade <strong>Frank Gio</strong> kommer närmast från storloppsvinst i Grupp I-loppet Prix Ourasi (€300.000) på Vincennes, men eftersom han är italienskfödd måste han visas upp för avelsvärderingsnämnden i Sverige och kan inte värderas som ”listhingst”.</p>



<p class="wp-block-paragraph">Det är inte första gången en italiensk hingst <a href="https://sulkysport.se/kronika/st-diskriminerar-italienska-avelshingstar/" data-type="link" data-id="https://sulkysport.se/kronika/st-diskriminerar-italienska-avelshingstar/" target="_blank" rel="noreferrer noopener">diskrimineras</a>. Samma visa var det med <a href="https://sulkysport.se/kronika/heja-danmark/" data-type="link" data-id="https://sulkysport.se/kronika/heja-danmark/" target="_blank" rel="noreferrer noopener">Vivid Wise As</a> eftersom Svensk Travsport har gjort vissa förändringar i avelsreglementet från 1 januari 2019. Då sas det att hästar från Italien inte kan listas på grund av den bristfälliga situationen i landets travsport med en mycket dåligt fungerande administration.</p>



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



<h2 class="wp-block-heading">Anmälda till avelsvärderingen:</h2>



<p class="wp-block-paragraph"><strong>Air Power </strong>(5 år e. Muscle Hill-Beyond Blue e. Cantab Hall)<br><em>1.08,9ak*/$378.491. 16 st: 5-3-1.</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna:</strong> finalerna i New Jersey Classic och New Jersey Sire Stakes.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/09/airpower892023lisa-617x346.jpg" alt="" class="wp-image-494196"/><figcaption class="wp-element-caption">Mattias Melander och Air Power. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph"><strong>D’Apper </strong>(5 år e. Walner-D’One e. Donato Hanover)<br><em>1.09,9ak/904.472 kr. 25 st: 8-1-2</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna: </strong>Fyraåringsstjärnan och försök i Sprintermästaren.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/07/dapper2272022lisa-617x346.jpg" alt="" class="wp-image-331611"/><figcaption class="wp-element-caption">D&#8217;Apper och Tim Tetrick. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph"><strong>Epic Kronos </strong>(5 år e. Muscle Hill-Firefly e. Ready Cash)<br><em>1.10,7am*/5.446.500 kr. 17 st: 10-1-2.</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna: </strong>finalen i Europaderbyt, Margaretas Tidiga Unghästserie, försök i Svenskt Travderby och tvåa i finalen i Svenskt Travderby.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/reden5-617x357.jpg" alt="" class="wp-image-645544"/><figcaption class="wp-element-caption">Epic Kronos vid segern i Europaderbyt på Vincennes. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph"><strong>Frank Gio</strong> (4 år e. Face Time Bourbon-Zarina Gio e. Ruty Grif)<br><em>1.11,6am/€682.400. 17 st: 11-3-0.</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna:</strong> Prix Ourasi, Gran Premio Carlo Marangoni, Prix Charles Tiercelin, Prix Pierre Plazen, Prix Penthesilea, Prix Coronis, Prix de Gien, Prix de Rome samt tvåa i italienskt Derby.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/00261766017scoopdyga-617x411.jpg" alt="" class="wp-image-660247"/><figcaption class="wp-element-caption">Frank Gio och Matthieu Abrivard. Foto: Scoopdyga </figcaption></figure>



<p class="wp-block-paragraph"><strong>Jigger</strong> (5 år e. Fabulos Wood-Little Jigger e. Muscle Hill)<br><em>1.13,2ak*/982.250 dkk. 15 st: 10-2-2.</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna: </strong>Jydsk 4-årings Grand Prix, tvåa i Danskt Kriterium och fyra i Danskt Derby.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/06/ay2x4692kopier-617x347.jpg" alt="" class="wp-image-603062"/><figcaption class="wp-element-caption">Jigger (1) och Steen Juul tar hem Jydsk 4-årings Grand Prix efter strid. Foto: Kjeld Mikkelsen/K M Photo</figcaption></figure>



<p class="wp-block-paragraph"><strong>Ol Dono Lengai </strong>(9 år e. Cantab Hall-Dodoma e. Varenne)<br><em>1.12,4ak/812.634 kr. 33 st: 19-7-2.</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna:</strong> klass I- och Klass II-försök.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/skarmavbild20250131kl.15.02.46-617x401.jpg" alt="" class="wp-image-683629"/><figcaption class="wp-element-caption">Ol Dono Lengai.</figcaption></figure>



<p class="wp-block-paragraph"><strong>Pretender U.S.</strong> (6 år e. Muscle Hill-Maven e. Glidemaster)<br><em>1.08,5ak/$818.748. 48 st: 11-6-7.</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna:</strong> finalerna i New Jersey Classic och New Jersey Sire Stakes, tvåa i Canadian Trotting Classic och trea i Valley Victory Trot.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/05/pretender1352022lisa-617x346.jpg" alt="" class="wp-image-301958"/><figcaption class="wp-element-caption">Pretender. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph"><strong>Venerate </strong>(7 år e. Love You-Peaceful Kemp e. Muscle Hill)<br><em>1.08,5ak*/$1.217.706. 47 st: 13-5-7.</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna:</strong> Mohawk Million, Kentucky Sire Stakes, Arthur J Culter Memorial och Maxie Lee Memorial.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/venerate2052023lisa-617x346.jpg" alt="" class="wp-image-447316"/><figcaption class="wp-element-caption">Venerate vid segern i Arthur J Cutler Memorial på 1.08,5 ifjol. Foto: Lisa Photo</figcaption></figure>



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



<p class="wp-block-paragraph"><strong>Branded By Lindy</strong> (6 år e. Chapter Seven-The Lindy Label e. Cantab Hall)<br><em>1.08,7ak*/$561.570. 25 st: 10-3-4.</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna:</strong> divisioner i Bluegrass och International Stallion Stakes samt final i Kentucky Championship Series.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/10/brandedbylindy22102021lisa-617x346.jpg" alt="" class="wp-image-231126"/><figcaption class="wp-element-caption">Branded By Lindy och Yannick Gingras. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph"><strong>Express Jet</strong> (11 år e. Goetmals Wood-Run For Jet e. Coktail Jet)<br><em>1.10,4ak/€632.220. 74 st: 8-7-9.</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna:</strong> Prix d’Antibes, Prix de Montelimar, Prix Bellino II, Prix de Rouen, Prix Ovide Moulinet, Grand Prix de Gelsenkirchen och trea i Criterium des 4 ans.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2019/02/ovidemoulinetarr1-617x355.jpg" alt="" class="wp-image-38572"/><figcaption class="wp-element-caption">Pierre Vercruysse och Express Jet vinner Prix Ovide Moulinet. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph"><strong>Jushua Tree</strong> (6 år e. Bold Eagle-Ma Sissi James e. Buvetier d’Aunou)<br><em>1.09,8am*/€1.026.650. 27 st: 20-1-0.</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna: </strong>Prix Jules Thibault, Prix Phaeton, Prix Gaston Brunet, Prix Octave Douesnel, Criterium Continental, Prix de Croix, Prix Bold Eagle, Prix d’Europe, Prix Jockey, Prix Marcel Laurent, Prix Doynel de Saint-Quentin samt tvåa i Criterium des 5 ans.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/julesthibault3-617x397.jpg" alt="" class="wp-image-456093"/><figcaption class="wp-element-caption">Jushua Tree. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph"><strong>Lovino Bello </strong>(4 år e. Village Mystic-Louvina Bella e. Buvetier d’Aunou)<br><em>1.09,7ak*/€585.255. 16 st: 7-4-3.</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna: </strong>Prix de l’Etoile/Prix Ready Cash, Criterium des 3 ans, Prix Henri Cravoisier, Prix Paul Viel och Prix Emmanuel Margouty.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/12/lovinobello1-617x430.jpg" alt="" class="wp-image-534832"/><figcaption class="wp-element-caption">Lovino Bello vinner för Eric Raffin. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph"><strong>Real de Lou</strong> (20 år e. Jag de Bellouet-Kooka de Lou e. Coktail Jet)<br><em>1.11,3m*/€434.550. 45 st: 15-4-3.</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna:</strong> Prix Louis Jariel, försök Grand National du Trot , Prix du Louvre, Prix Pythia och Prix de Provence.</p>



<p class="wp-block-paragraph"><strong>Avelshingst: </strong>803 registrerade avkommor i Frankrike. Vinstrikaste avkommor: Django du Bocage ($588.450), Daida de Vandel (€492.280), Excellent (€480.340), Inshore ($439.750) och Dorgali (€422.830).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/realdeloumal-617x333.jpg" alt="" class="wp-image-683634"/><figcaption class="wp-element-caption">Real De Lou med Laurent-Claude Abrivard. Foto Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph"><strong>Sig Sauer </strong>(4 år e. Muscle Hill-Sigilwig e. Donato Hanover)<br><em>1.08,1ak*/$1.151.312. 15 st: 9-0-1.</em></p>



<p class="wp-block-paragraph"><strong>Största segrarna:</strong> finaler i Breeders Crown, New Jersey Sire Stakes, New Jersey Classic, division I Stanley Dancer Memorial, Earl Beal Jr. Memorial och Kentucky Futurity.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/sigsaueramm241006adamstromstalltz-617x411.jpg" alt="" class="wp-image-643242"/><figcaption class="wp-element-caption">Sig Sauer och Andrew McCarthy tar hem Kentucky Futurity. Foto: Adam Ström/stalltz.se</figcaption></figure>
