
<p class="wp-block-paragraph">Ett merittungt sällskap visas upp på Solvalla, som bland annat vunnit Svensk Uppfödningslöpning, Svenskt Travkriterium och Europaderbyt, men också en hingst som blott gjort tre starter.</p>



<p class="wp-block-paragraph">Listhingstarna har också meriter. Vad sägs om en Elitloppsvinnare, Criterium des 3 ans-etta och en Hambletonian-trea?</p>



<p class="wp-block-paragraph">Nedan hittar du de avelshingstar som ska synas av avelsvärderingsnämnden.</p>



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



<h2 class="wp-block-heading">Avelshingstar som visas på Solvalla:</h2>



<p class="wp-block-paragraph"><strong>Barack Face </strong>(5 år e. Ready Cash-Lisa America e. Varenne)<br><em>1.11,1ak/5.828.500kr. 18 st: 7-3-1.</em><br><strong>Meriter: </strong>segrar i Europaderbyt, Margaretas Tidiga Unghästserie och andraplats i Svenskt Travderby och final i Breeders Course.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/12fameandglory2-617x333.jpg" alt="" class="wp-image-509570"/><figcaption class="wp-element-caption">Fame and Glory vann Svenskt Trav-Kriterium för Björn Goop. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Fame and Glory </strong>(4 år e. Tactical Landing-Olympia Tilly e. Lindy Lane)<br><em>1.12,5al*/5.260.000 kr. 8 st: 6-2-0.</em><br><strong>Meriter:</strong> seger i Svenskt Travkriterium och finaltvåa i Breeders Crown.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/justicem221001adam-617x333.jpeg" alt="" class="wp-image-520896"/><figcaption class="wp-element-caption">Justice och Åke Svanstedt vid vinst på Red Mile. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph"><strong>Justice</strong> (5 år e. Chapter Seven-Religulous e. Muscles Yankee)<br><em>1.08,6ak*/4.393.558 kr. 28 st: 12-4-1.</em><br><strong>Meriter:</strong> segrar i Bluegrass Series, Empire Breeders Classic, Muscle Hill och fyra försök i New York Sire Stakes.</p>



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



<p class="wp-block-paragraph"><strong>Nero Schermer</strong> (4 år e. Face Time Bourbon-Sultania e. Self Possessed)<br><em>1.15,4am/46.317 kr. 3 st: 2-0-1.</em><br><strong>Meriter:</strong> –</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/02/rockywinnerheat-617x333.jpg" alt="" class="wp-image-548136"/><figcaption class="wp-element-caption">Rocky Winner. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Rocky Winner </strong>(16 år e. Credit Winner-Level Fortytwo e. Arnaqueur)<br><em>1.10,5ak/6.777.289 kr. 119 st: 26-12-15.</em><br><strong>Meriter: </strong>segrar i V75:s Jubileumslopp, Prix de Boissy-Saint-Leger, Prix du Palais de Chaillot, Prix du Medoc, Prix de la Concorde, Prix de Montignac-Charente, Prix de la Mediterranee och Prix Jules Roucayrol.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/tetrickwania1-617x333.jpg" alt="" class="wp-image-427376"/><figcaption class="wp-element-caption">Tetrick Wania och Conrad Lugauer. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Tetrick Wania </strong>(5 år e. Muscle Hill-Random Destiny e. Ken Warkentin)<br><em>1.11,8am*/3.073.425 kr. 15 st: 6-3-1.</em><br><strong>Meriter: </strong>seger i Svensk Uppfödningslöpning, Svampen och tvåa i Konung Gustaf V:s Pokal.</p>



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



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2017/09/bornintheusa-617x257.jpg" alt="" class="wp-image-12624"/><figcaption class="wp-element-caption">Born In the U.S.A. Foto Mia Törnberg.</figcaption></figure>



<p class="wp-block-paragraph"><strong>Born in the U.S.A.</strong> (11 år e. Muscle Hill-Christina Rose e. Chocolatier)<br><em>1.11,9am/2.059.414 nok. 15 st: 9-2-0.</em><br><strong>Meriter:</strong> vinster i Treåringsstjärnan, Hans Petter Tholfsens Minneslopp, Habibs Minneslopp och tvåa i Europaderbyt.<br><strong>Övrigt: </strong>verkat som avelshingst i Norge, första kullen föddes 2019 och har 114 registrerade avkommor. Tre i topp: <strong>Born In the Bergen</strong> (1.349.000 nok), <strong>Bunny</strong> (948.500 nok) och <strong>Olympic Winnner </strong>(424.850 nok)</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/05/etonnantabmal220529adamstromstalltz-617x436.jpg" alt="" class="wp-image-308588"/><figcaption class="wp-element-caption">Etonnant vinner Elitloppet. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph"><strong>Etonnant </strong>(10 år e. Timoko-Migraine e. Alligator)<br><em>1.09,1ak/2.526.710 euro. 87 st: 22 segrar.</em><br><strong>Meriter: </strong>segrar i Elitloppet, Grand Criterium de Vitesse, Grand Prix de Wallonie, Kymi Grand Prix, Prix de l’Atlantique, Prix de Paris, Prix des Ducs de Normandie.<br><strong>Övrigt: </strong>verkat i aveln i Frankrike, första kullen föddes 2021 och har 126 registrerade avkommor. Tre i topp: <strong>Luxor de Villabon</strong> (€39.010), <strong>Lucky Sibey</strong> (€31.110) och <strong>Le Grand Zampano</strong> (€3.625).</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/01/prixourasi1-617x411.jpg" alt="" class="wp-image-546472"/><figcaption class="wp-element-caption">Krack Time Atout spurtar hem Prix Ourasi för Paul-Philippe Ploquin. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph"><strong>Krack Time Atout </strong>(4 år e. Face Time Bourbon-Topaze d’Atout e. Coktail Jet)<br><em>1.12,1l*/444.600 euro. 23 st: 5 segrar.</em><br><strong>Meriter:</strong> vinster i Prix de Berlin, Criterium des 3 ans och Prix Ourasi.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/08/temporalhanoverokh220730adamstromstalltz-617x400.jpg" alt="" class="wp-image-336361"/><figcaption class="wp-element-caption">Temporal Hanover och Örjan Kihlström. Foto Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph"><strong>Temporal Hanover </strong>(5 år e. Walner-Think Twice e. Cantab Hall)<br>1.08,4ak/972.166 dollar. 25 st: 9-8-2.<br><strong>Meriter: </strong>vinster i Champlain Stakes, Earl Beal Jr. Memorial, International Stallion Stakes, Zweig Memorial, tvåa i Kentucky Futurity och trea i Hambletonian Stakes.<br><strong>Övrigt: </strong>sattes i aveln 2023 och betäckte 137 ston i USA.</p>



<p class="has-text-align-center wp-block-paragraph">***</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. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph"><strong>Venerate </strong>(6 år e. Love You-Peaceful Kemp e. Muscle Hill)<br><em>1.08,5ak*/1.119.677 dollar. 40 st: 12-4-6.</em><br><strong>Meriter: </strong>segrar i Arthur J. Cutler Memorial, Kentucky Sire Stakes, Mohawk Million, tvåa i John Cashman Memorial samt finaltrea i Breeders Crown och Peter Haughton Memorial.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/11/wb111222r8volumeeight-617x346.jpg" alt="" class="wp-image-379777"/><figcaption class="wp-element-caption">Volume Eight och Andrew McCarthy. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph"><strong>Volume Eight </strong>(4 år e. Chapter Seven-Lass A Rope e. Encore Encore)<br><em>1.09,6ak*/434.002 dollar. 10 st: 7-0-0.</em><br><strong>Meriter: </strong>segrar i International Stallion Stakes, Kindergarten Series och Valley Victory.</p>
