<p>– Jag har fått besked om det från kretsen runt hästen nu på förmiddagen, säger Jägersros sportchef <strong>Mats Ahlkvist</strong> och tillägger:</p>
<p>– Men jag har flera bra aspiranter som vill ha den sista platsen i loppet.</p>
<p>Av de sju hästar som tidigare var inbjudna, plus<strong> Milligan’s School</strong> som vann Årjängs Stora Sprinterlopp och fick en friplats på det, försvann den inbjudne franske <strong>Bel Avis</strong> efter förra veckans formsvaga insats i Les Sables d’Olonne. Istället har italienske topphästen <strong>Vitruvio</strong>, som i sin senaste start vann Kymi GP i Finland kommit in i Åbergs, liksom <strong>Daniel Redéns</strong> sto <strong>Double Exposure</strong> (e. Donato Hanover – K.D.Girl) vilken Elitloppshelgen vann på 1.09,9 och med tiden är Europas tredje snabbaste sto i år.<strong> Billie de Montfort</strong> gick 1.09,8 i Gävle i maj och Sharon Gar 1.09,8 som tvåa bakom <strong>Zacon Gio</strong> i Padova i juni.</p>
<p>– Eftersom <strong>Björn Goop</strong> ska köra <strong>Vitruvio</strong> som han ju nu har i träning lär det bli <strong>Erik Adielsson</strong>, vilken körde Ecurie D. när denne vann på 1.09,2 Elitloppshelgen, som ska köra Ecurie D., säger Mats Ahlkvist.</p>
<figure id="attachment_44552" aria-describedby="caption-attachment-44552" style="width: 1300px" class="wp-caption alignright"><a href="https://sulkysport.se/wp-content/uploads/2019/05/alessandrogocciadoro20.jpg"><img class="size-full wp-image-44552" src="https://sulkysport.se/wp-content/uploads/2019/05/alessandrogocciadoro20.jpg" alt="trav, travsport, sulkysport, solvalla, elitloppet, gocciadoro" width="1300" height="1080" /></a><figcaption id="caption-attachment-44552" class="wp-caption-text">Vitruvio. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>
<p>Spårlottningen till Hugo Åbergs Memorial görs på Jägersro under morgondagens tävlingar.</p>
<p>– Det blir ett kanonlopp med bland annat tre spännande hemmahästar i fältet, <strong>Campo Bahia</strong>. <strong>Racing Mange</strong> och<strong> Tae Kwon Deo</strong>, obesegrade fyraårige Ecurie D. vilken nu ska ut mot världseliten och till det kommer sådana topphästar som Vitruvio och <strong>Cokstile</strong>. Det är klart att det känns jättetrist att vi måste köra ett sådant här kanonlopp med tomma publikplatser på grund av coronapandemi-restriktionerna. Det kan bli ett fantastiskt lopp, men utan den magiska och förväntansfulla stämning med fullsatta publikplatsersom det alltid blir när Åbergs ska köras. Men det är som det är och vi måste ha respekt för att de restriktoner som finns är till för att förhindra smittspridning av en en farlig sjukdom, säger Mats Ahlkvist.</p>
<h2>Klara hästar</h2>
<p><em>Hugo Åbergs Memorial, Jägersro tisdag 28 juli, 1.609 meter autostart. Förstapris 1.609.000 kronor:</em></p>
<ul>
<li><strong>Ble du Gers</strong> (franskfödd valack nio år e. Quinoa du Gers – Moorea) – tränare: Frode Hamre</li>
<li><strong>Campo Bahia</strong> (svenskfödd hingst fem år e. Muscle Hill – Americandream A.T.)– Conrad Lugauer</li>
<li><strong>Cokstile </strong>(norskfödd hingst sju år e. Quite Easy – Joystile) – Wim Paal</li>
<li><strong>Double Exposure</strong> (USA-fött sto sju år e. Donato Hanover – K.D.Girl) – Daniel Redén</li>
<li><strong>Ecurie D.</strong> (danskfödd fyra år e. Infinitif – To Soon) – Frode Hamre</li>
<li><strong>Milligan’s Scool</strong> (USA-född sju år e. Yankee Glide – Tori Ann) – Stefan Melander</li>
<li><strong>Racing Mange</strong> (svenskfödd hingst sju år e. Orlando Vici – Kära Kickan) – Joakim Lövgen</li>
<li><strong>Tae Kwon Deo</strong> (USA-född hingst fem år Muscle Hill – Brigham Dream) – Adrian Kolgjini</li>
<li><strong>Vitruvio</strong> (italienfödd hingst sex år e. Adrian Chip – Tigre Om) – Björn Goop</li>
</ul>
<p>En plats återstår att fylla i fältet som ska innehålla tio hästar.</p>
<blockquote class="wp-embedded-content" data-secret="PI0ODESJbV"><p><a href="https://sulkysport.se/beslutet-om-abergs-memorial/">Beslutet om Åbergs Memorial</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Beslutet om Åbergs Memorial” &ndash; Sulkysport" src="https://sulkysport.se/beslutet-om-abergs-memorial/embed/#?secret=EbEHTCRVDr#?secret=PI0ODESJbV" data-secret="PI0ODESJbV" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="GDdDkXFgfb"><p><a href="https://sulkysport.se/elitloppstvaan-cokstile-flyttas/">Elitloppstvåan Cokstile flyttas</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Elitloppstvåan Cokstile flyttas” &ndash; Sulkysport" src="https://sulkysport.se/elitloppstvaan-cokstile-flyttas/embed/#?secret=o7NcTTAicx#?secret=GDdDkXFgfb" data-secret="GDdDkXFgfb" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="PhUD46FFx3"><p><a href="https://sulkysport.se/vitruvio-svaret-i-kymi-grand-prix/">Vitruvio svaret i Kymi Grand Prix</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Vitruvio svaret i Kymi Grand Prix” &ndash; Sulkysport" src="https://sulkysport.se/vitruvio-svaret-i-kymi-grand-prix/embed/#?secret=n6Fc0TN2Bc#?secret=PhUD46FFx3" data-secret="PhUD46FFx3" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="Of1uFdiy4e"><p><a href="https://sulkysport.se/nytt-storlopp-till-ble-du-gers/">Nytt storlopp till Ble du Gers</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Nytt storlopp till Ble du Gers” &ndash; Sulkysport" src="https://sulkysport.se/nytt-storlopp-till-ble-du-gers/embed/#?secret=5FnEboeSqw#?secret=Of1uFdiy4e" data-secret="Of1uFdiy4e" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="CiH260eTsx"><p><a href="https://sulkysport.se/tokoppning-baddade-for-seger/">Toköppning bäddade för seger</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Toköppning bäddade för seger” &ndash; Sulkysport" src="https://sulkysport.se/tokoppning-baddade-for-seger/embed/#?secret=VZegOH7F9s#?secret=CiH260eTsx" data-secret="CiH260eTsx" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="9UrPI2awo1"><p><a href="https://sulkysport.se/lopningsrekord-i-kalmarsundspokalen/">Löpningsrekord i Kalmarsundspokalen</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Löpningsrekord i Kalmarsundspokalen” &ndash; Sulkysport" src="https://sulkysport.se/lopningsrekord-i-kalmarsundspokalen/embed/#?secret=cko0AA6Qj0#?secret=9UrPI2awo1" data-secret="9UrPI2awo1" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="lyWM38XhA7"><p><a href="https://sulkysport.se/cokstile-grym-fran-dodens/">Cokstile grym från dödens</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Cokstile grym från dödens” &ndash; Sulkysport" src="https://sulkysport.se/cokstile-grym-fran-dodens/embed/#?secret=tl7BpbyWNy#?secret=lyWM38XhA7" data-secret="lyWM38XhA7" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="fkJNexrw8Z"><p><a href="https://sulkysport.se/kronika/krigade-till-sig-elitloppsbiljett/">Krigade till sig Elitloppsbiljett</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Krigade till sig Elitloppsbiljett” &ndash; Sulkysport" src="https://sulkysport.se/kronika/krigade-till-sig-elitloppsbiljett/embed/#?secret=0eUYusVhzp#?secret=fkJNexrw8Z" data-secret="fkJNexrw8Z" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="Cur7gauiWm"><p><a href="https://sulkysport.se/kronika/kaxig-sjuaring-bast-i-arjangs-storlopp/">Kaxig sjuåring bäst i Årjängs storlopp</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Kaxig sjuåring bäst i Årjängs storlopp” &ndash; Sulkysport" src="https://sulkysport.se/kronika/kaxig-sjuaring-bast-i-arjangs-storlopp/embed/#?secret=Ge7qhnlmEO#?secret=Cur7gauiWm" data-secret="Cur7gauiWm" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
