
<p class="has-drop-cap wp-block-paragraph">Bergsåker i fokus den här helgen och som avslutning på lördagens V75-omgång avgörs Sundsvall Open Trot med en miljon kronor till vinnaren. Klar favorit blir Björn Goops <strong>San Moteur</strong> (V75-7) och vi klandrar inte dem som spikar sexåringen. Vi väljer dock två andra spikar i omgången och plockar med såväl <strong>Hail Mary </strong>som hemmahoppet<strong> Borups Victory</strong> i huvudloppet.</p>



<p class="wp-block-paragraph">Kallblods-SM återfinns också på kupongen. <strong>Månlykke A.M.</strong> jagar sin fjärde raka inteckning i loppet, men vi spikar istället <strong>Bäcklös Uriel </strong>(V75-3) som vi hoppas når ledningen, får bestämma en bit och sedan rinner undan. Omgångens chansspik är <strong>Maybach W.F. </strong>(V75-5) i ett annars streckkrävande lopp. Även här är scenariot ”spets och slut”.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/08/26v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Bergsåker.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-08-26_9_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-08-26_9_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-08-26_9_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Silverdivisionen, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Kagan </strong>har radat upp fina prestationer på slutet utan att få vinna och nu tycker vi verkligen att det är hans tur snart. Femåringen var första reserv till ”Margareta-Pokalen” på Solvalla nyligen, så stall Bergh har höga tankar om honom. Från det här fina läget lär han få ett bra lopp och han blir vår första häst.</li>



<li><strong>Comes With Age </strong>var inte tom när galoppen kom knappa halvvarvet från mål senast. Vi är helt inne på att den galoppen berodde på folk som helt plötsligt stod på innerplan då det handlar om en ”tittig” häst som gärna ser spöken både lite här och där. Kvick från start och spetsfavorit – leder länge om han slipper orosmoment på vägen.</li>



<li><strong>Devils Tongue </strong>hade nog blivit tipsetta från framspår då det här är en häst vi gillar. Han vann bara med knapp marginal i Finland senast, men det är inte typen av häst som gör mer än vad han behöver. Då satt skorna på bak, nu blir det barfota runt om och rygg på startsnabb häst här behöver inte vara fel.</li>



<li><strong>Mellby Joker </strong>är kvick från start och trivs på innerspår, så trots spår en bit ut nu så lär Wäjersten säkert prova att trycka av honom rejält. Formen sitter där och hittar man bara ner i vettigt läge är han med och gör upp om det.</li>



<li><strong>L.A.Boko </strong>väljer tränaren bort, men vi tycker inte det skiljer så mycket mellan Wäjerstens båda bidrag i loppet. L.A.Boko höll bra bakom Castor The Star senast efter att ha fått göra grovjobbet i ”dödens” sista 1400 m. Han ska inte glömmas bort.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 3-2-9 <strong>B: </strong>6-5-11 <strong>C: </strong>8-12-4-7-1-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Flera snabba över sprinterdistans lär innebära bra fart första halvvarvet. Med tanke på lägena är det ändå<strong> Comes With Age </strong>som får ikläda sig favoritskapet att ta hand om ledningen. Även om såväl <strong>Joy Alissa</strong> som <strong>Mellby Joker </strong>och <strong>Kagan</strong> är kvicka i fötterna.</p>



<h2 class="wp-block-heading">Avd 2 – Klass II, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Ringo Adore </strong>har vi blivit smått förtjusta i på slutet. Han fick nöja sig med andraplatsen senast, men det var bakom Working Class Hero som ju vann sin derbyuttagning i tisdags. Även om det är bra emot så finns kanske inga hästar riktigt av den kalibern med här. Spåret är såklart ingen höjdare, men han får ändå vår tipsetta.</li>



<li><strong>Decathlon </strong>har varit rejäl i samtliga årets tre starter och har fin kapacitet för lägsta STL-klassen. Rimligen ska han gå lite framåt för varje start och nu när det är autostart så åker jänkarvagnen på igen. Från ett fint spår är han ett givet streck.</li>



<li><strong>Natural Mine </strong>känns intressant på flera sätt. Dels pratar man från stall Westholm om att rycka alla fyra skorna igen. På den balansen avslutade han rappt näst senast, dock efter att ha galopperat i första sväng. Dels hoppar Björn Goop upp i sulkyn för första gången och det är alltid spännande på Westholm-tränade hästar.</li>



<li><strong>Perkins </strong>hade tagit comebacken på rätt sätt och vann enkelt på Solvalla senast. Precis som vid hästens samtliga tre segrar i karriären handlade det då om tidig ledning. Bakspår den här gången gör att han åker ner något hack i rankingen.</li>



<li><strong>Staro Quantas </strong>blev kvar invändigt med sparade krafter på Solvalla senast och formen är bättre än vad raden visar. Vi tror det kan bli svårt att rå på de fyra vi rankat före honom, men letar man skräll är han absolut streckvärd.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 8-2 <strong>B: </strong>4-9 <strong>C: </strong>6-10-7-3-5-1-11-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> <strong>Natural Mine </strong>tog ledningen från samma läge på Östersund i juni och vi tror han är först till plankan även här. Sedan är frågan om man vill köra där? Om inte så kan <strong>Ringo Adore</strong>, trots spår åtta, få överta om man kör offensivt.</p>



<h2 class="wp-block-heading">Avd 3 – Svenskt Mästerskap, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Bäcklös Uriel </strong>trodde vi skulle dra flera ”tidiga streck” på sig än vad han verkar göra. Hästen har stått för en remarkabel utveckling i år och det faktum att han tidigare kanske inte har de allra vassaste meriterna över lång distans, det tar vi inte då hårt på. Han är ”en annan häst” nu och med sin startsnabbhet talar mycket för att han blåser till spets här. Med lite tur får han då fuska bort några hundra meter av loppet och då tror vi på bra segerchans.</li>



<li><strong>Järvsöodin </strong>är stallkamrat med tipsettan och en av sex (!) Jan-Olov Persson-hästar i det här SM-loppet. Järvsöodin kommer från mersmakande seger senast och såg då inte tom ut över mål efter en avslutning strax under 18,5/700 m. Han bör med tidigt vid gardering.</li>



<li><strong>Månlykke A.M. </strong>tog sin senaste seger just när det vankades SM förra året, då från spår åtta bakom bilen. Han jagar nu sin fjärde raka inteckning i loppet men hade inte heller den här gången något flyt i spårlottningen. Riskerar att bli fast invändigt och rankas därför ner som trea. Även om vi har stor respekt för hans grundkapacitet.</li>



<li><strong>Pydin </strong>har tidigare i karriären agerat väldigt ojämnt, men i år har han blivit rena ”bankomaten” med jämna och säkra prestationer hela tiden. Hästarna brukar utvecklas till sprinters med åren, men med rätt löpning är vi inne på att Pydin fortsatt står sig bra över lång distans. Han ska passas om man letar outsiderbud.</li>



<li><strong>B.W.Sture </strong>har strulat till det en hel del på slutet med galopper. Nu blir det skor på alla fyra hovarna, vilket borde göra honom mer stabil. Kapacitet finns där och ett platsbud är han.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 4 <strong>B: </strong>5-1-11-8-3-10 <strong>C: </strong>7-6-2-9</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Från perfekt läge bör<strong> Bäcklös Uriel </strong>dra till ledningen direkt. Stall Persson har ännu en startsnabb häst i <strong>Järvsöodin</strong>, men även om Bäcklös Uriel knappast är gynnad av lång distans så tror vi man vill prova honom där nu.</p>



<h2 class="wp-block-heading">Avd 4 – Lars Lindbergs Minne, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Imhatra Am </strong>är väl egentligen ett rimligt spikförslag då hon går ner rejält i klass efter att till exempel varit trea bakom Great Skills i Sto-EM senast. Utan strul bör det gå vägen, men statistik är statistik och vi kan inte helt blunda för det faktum att det är i den här typen av lopp – för ston med lärlingar i sulkyn – som det brukar kunna smälla till. Därför väljer vi istället två andra spikar i omgången och garderar Imhatra Am.</li>



<li><strong>Young Mistress </strong>är obesegrad med Niclas Hammarström efter två starter tillsammans. De skrällvann V75-lopp från samma läget på Östersund i juni och man skulle kunna vinna igen, om än inte lika lite betrodd. Hästen är ingen raket från start, men trivs ypperligt med en smygare i det längsta och fritt spurtutrymme till slut.</li>



<li><strong>Kit Crown </strong>vann på bra sätt under elitloppshelgen på Solvalla, men har sedan inte fått till det. Senast blev det startgalopp, men man rapporterar från stall Tjomsland att man haft det här loppet i sikte ett tag och läget blev intressant. Hon kan trampa iväg bra från start och är vår knappa spetsfavorit efter en bit.</li>



<li><strong>Thelma M.M. </strong>vill vi varna lite extra för. Hon har visserligen ett lite lurigt femtespår i volten, men reder bara körande Felicia Molin ut den problematiken är vi inne på att man är med i segerstriden. Hästen svarade för mycket rejäla sista 700 m senast på Rättvik</li>



<li><strong>Donna Summer </strong>är ingen enkel donna, men fart och styrka finns som duger bra i klassen. Galopprisken finns, men Malte Handfast tycker vi gör skäl för sitt efternamn och ska nog greja det där. Streckad på ett fåtal procent känns ekipaget intressant.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 13 <strong>B: </strong>1-7-5-9-4-6-8<strong> C: </strong>3-10-11-2-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Voltstart och bara ston. <strong>Mitzy Gold</strong> har spår fyra, men brukar komma iväg snabbt från de flesta lägen. Om <strong>Kit Crown </strong>sköter sig så tror vi dock att hon från springspår är den som tidigt kommer till ledningen. Värst emot från det andra springspåret är <strong>Athena Face</strong>.</p>



<h2 class="wp-block-heading">Avd 5 – Bronsdivisionen, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Maybach W.F. </strong>är en kul chansspik i ett lopp som annars kräver en hel del streck. Vi bygger det hela på att vi tror han tar hand om ledningen från spår ett (som inte alls är så dumt på Bergsåker) och i den positionen trivs han bra. Sju gånger har han tävlat i spets, sju segrar har det blivit. Det enda som möjligen oroar är den rejäla tömningen han fick senast på Skellefteå efter att ha blivit hängande i tredjespår, men det här är en tuffing och vi tror han skakar av sig det.</li>



<li><strong>Eldorado </strong>är tidig för oss vid gardering. Hästen är visserligen klar för final i KGB:s Minne under derbyhelgen, men det låter ändå uppåt från Troels Andersen som skulle kunna få ett lopp i rygg på vår spikidé om han väljer att rygga denne. Kommer sedan luckan till slut blir vi inte förvånade om det räcker ända fram – bortglömd.</li>



<li><strong>Dragons Bar </strong>har ett trist läge och efter hans dubbla galopper senast på Axevalla så åker han ner något hack i rankingen. Lång distans känns i grunden inte som några konstigheter, bara hästen står på fyra fräscha ben.</li>



<li><strong>Hobart </strong>står finfint inne på pengarna och gillar lång distans. Även om läget nu inte blev det bästa så ska han absolut passas om man garderar loppet vidare.</li>



<li><strong>No Limit Express </strong>kliver upp i klass, men det brukar inte skilja jättemycket gällande kapacitet på Klass ett- och bronsdivisionshästar. Han hade sparat bakom Working Class Hero senast och kan absolut vara med där framme igen.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 1-9 <strong>B: </strong>12-7-4-2-5-3 <strong>C: </strong>11-8-6-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Innerspår på Bergsåker är inte alls så tokigt just på Bergsåker och <strong>Maybach W.F. </strong>är rätt så kvick den första biten. Skulle man lyckas hålla spets låter det som att man vill köra där också. <strong>Fenix Brick </strong>med Goop för första gången skulle kunna utmana.</p>



<h2 class="wp-block-heading">Avd 6 – Klass I, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Galant Ima </strong>ska testas barfota runt om för första gången här och det fastnar vi för. Känslan är att han har den typen av aktion där det kommer att passa finfint, vilket även tränare Roger Nilsson är inne på. Kanske blir det ingen ledning med några startsnabba utvändigt, men en bra position lär Mats E Djuse skaffa fyraåringen. Vår tipsetta i smålurigt lopp.</li>



<li><strong>Classic Pan </strong>gör långresan från Axevalla i angeläget ärende. Han verkar vara inne i en fin fas och visade näst senast från samma spår att han kan öppna klart bra. Verkar bli lite borttappad av spelarna, vi streckar tidigt.</li>



<li><strong>Kendall Jackson </strong>är den tidiga favoriten, mycket såklart på kombinationen Nurmos/Djuse. Han avgjorde på bra sätt senast efter att ha fått göra en hel del jobb ute i spåren under slutvarvet. Bricka tolv underlättar inte, men utan strul är han såklart med och gör upp om det.</li>



<li><strong>Danao Degli Dei </strong>fick starta tre gånger under samma kväll i samband med Axevallas trippeltrav och i det avslutande skiljeheatet stod han inte alls att känna igen. Har fått pusta lite efter det och återkommer nu med nyladdade batterier. Löper han upp till vad han i grund och botten kan så lär han fälla de flesta.</li>



<li><strong>Denco´s Rioja </strong>kan slå till om allt stämmer. Hon är effektiv om hon får smyga med på innerspår och sedan få fritt spurtutrymme till slut.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 2-4-12-9 <strong>B:</strong> 5-3-6-8-1 <strong>C: </strong>10-11-7</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> <strong>Solöns Skrammel </strong>borde ha vettig chans att ta sig förbi Roger Nilssons båda hästar invändigt. Över 1.640 meter är sedan det mest troliga scenariot att man fortsatt vill köra där. Utmanas främst av <strong>Classic Pan</strong>, men sida vid sida säger vi fördel <strong>Solöns Skrammel</strong>.</p>



<h2 class="wp-block-heading">Avd 7 – Sundsvall Open Trot, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>San Moteur </strong>stod över Åby Stora Pris och fokuserade tidigt istället mot årets upplaga av Sundsvall Open Trot. Det kan vara så enkelt att han bara vinner oavsett position, men vi vill ändå syna honom som klar favorit. Det mesta är annars skrivet om Håkan Arvidssons stjärna och kapacitetmässigt räds han såklart ingen i fältet.</li>



<li><strong>Hail Mary </strong>kommer från seger i Hugo Åbergs Memorial och är ingen motståndare man leker med hur som helst. Läget blev perfekt och eftersom vi tror att man släpper med Click Bait över full distans så borde vägen mot ledningen ligga öppen. Väl i den positionen är han hästen att besegra.</li>



<li><strong>Borups Victory </strong>kan visa sig vara ett lyxstreck, men vi har den största respekt för Daniel Wäjerstens förmåga att ställa iordning hästarna till rätt lopp. Nu handlar det om hemmabanans största drabbning för året och det var sannerligen inga fel på Borups Victorys avslutning bakom Francesco Zet senast i ”Margareta-Pokalen”.</li>



<li><strong>Power </strong>har ett läge som är småintressant. Bör kunna slinka igenom bra och hästen är sedan vass om han får en vilsam löpning samtidigt som de bästa får offra lite kraft efter vägen. Då skulle han kunna vara en utmanar om segern till och med.</li>



<li><strong>Charmant De Zack </strong>vann så sent som i lördags. Det gulddivisionsloppet höll dock inte samma klass och här tror vi han får tufft att rå på de allra bästa. Mer ett platsbud än någon het segerkandidat.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 6 <strong>B: </strong>2-4-9-5-1 <strong>C: </strong>7-3-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Inget snack om att <strong>Click Bait </strong>är snabb nog att försvara ledningen, men nästan lika givet är det att man väljer att släppa mot de här hästarna över medeldistans. Då borde <strong>Hail Mary</strong> vara den som är mest aktuell för ledningen in mot första sväng.</p>



<p class="wp-block-paragraph">	
				<div class="factbox full ">
			<div class="insidefactbox">
				<div class="overflow">
					<div class="height">
						<div class="padding">
							<div class="factvinjett">Fakta</div>
							
															<h3 class="title">
									V75-FÖRSLAGET 26 AUGUSTI								</h3>
														<div class="content">
								
<p class="wp-block-paragraph"><strong>Avd 1:</strong> 2,3,5,6,9,11 (8,12)<br><strong>Avd 2:</strong> 2,4,8,9 (6,10)<br><strong>Avd 3:</strong> 4 Bäcklös Uriel (5,1)<br><strong>Avd 4:</strong> 1,4,5,6,7,8,9,13 (3,10)<br><strong>Avd 5:</strong> 1 Maybach W.F. (9,12)<br><strong>Avd 6:</strong> 2,3,4,5,6,9,12 (8,1)<br><strong>Avd 7:</strong> 2,4,6 (9,5)</p>



<p class="wp-block-paragraph"><em>4.032 rader / 2.016 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
