✔ Checklista inför stämman ✔ kallelse ✔ digitala stämman ✔ klander & motioner ✔ genomförande ✔ Tips för en lyckad årsstämma

<h4 class="wp-block-heading">✔ Checklista inför stämman  ✔ kallelse  ✔ digitala stämman  ✔ klander &amp; motioner  ✔ genomförande  ✔ Tips för en lyckad årsstämma  ✔ Protokollförare </h4>



<h4 class="wp-block-heading">Många föreningsstämmor hägrar runt hörnet – därför kan det vara hög tid att fräscha upp kunskaperna. De viktigaste frågorna på stämman är normalt val av styrelse och revisorer, fastställande av föreningens redovisning och uttaxeringen. Sedan 1 januari är det dessutom möjligt att hålla digitala stämmor. I månadens djupdykning går vi igenom det viktigaste att tänka på inför, under och efter stämman.&nbsp;</h4>



<p>När det är dags för årsstämma så gäller det att förbereda sig bra. Dessutom kan det ta tid för styrelsen att samla ihop allt underlag, så det är viktigt att börja i tid. Information om ärenden som omfattar större investeringar, banklån, försäljning av tillgångar eller andra beslut som påverkar föreningens framtid måste komma till medlemmar i tid. </p>



<p>– Bjud på fika under stämman, det är en trevlig grej som ger mer än vad man tror. Det är ett tillfälle att träffa medlemmar och göra dem delaktiga. Stämman är formell, men det är också ett socialt tillfälle att träffa varandra, säger Cecilia Wendin, styrelseordförande och rådgivare på Samfälligheterna.&nbsp;</p>



<h4 class="wp-block-heading">När, var och hur</h4>



<p>I föreningens stadgar framgår bestämmelserna för föreningsstämman. Där bör det bland annat framgå när och hur man planerar att hålla stämman, när kallelsen ska gå ut till medlemmarna och vad som ska framgå i den.&nbsp;</p>



<h4 class="wp-block-heading">Kallelse – styrelsens ansvar &amp; viktigaste faktor</h4>



<p>Det är styrelsen som ansvarar för att kallelse går ut i tid, och att den är korrekt utformad. I kallelsen bör det framgå när och vart stämman sker, ärenden och andra frågor som är relevanta för stämman. Här vilar ett stort ansvar på styrelsen eftersom en felaktig kallelse är grund för klander.&nbsp;</p>



<p>Kallelsen bör gå ut i skriftligt format, så att det inte uppstår några frågetecken om huruvida alla medlemmar har fått kallelsen eller inte. Det skadar inte att skicka kallelse via både post och e-post.&nbsp;</p>



<p>Det är viktigt att kallelsen med tillhörande information som debiteringslängd, utgifts- och inkomststat och motioner går ut i tid till medlemmarna. Om relevant information inte går ut med kallelse, ska det finnas tydliga hänvisningar till var medlemmarna kan vända sig för att hitta relevanta dokument.</p>



<p>– En av de allra viktigaste punkten på stämman är att förbereda och lägga fram en korrekt debiteringslängd. Skulle debiteringslängden vara fel är du rökt om du vill driva in skulder vid behov, säger Cecilia.&nbsp;</p>



<h4 class="wp-block-heading">Motioner </h4>



<p>Kallelsen ska innehålla de ärenden <em>(tex motioner)</em> som stämman ska behandla. Skulle styrelsen missa ett ärende i sin kallelse, ska stämman inte heller behandla det på stämman. Syftet med kallelsen är att alla medlemmar ska ha möjlighet att påverka eventuella beslut, något som blir svårt om medlemmarna inte vet om att det kommer på stämman.&nbsp;</p>



<p>– Medlemmarna har rätt att lyfta sina frågor under stämman, oavsett om de är med på dagordningen eller inte. Dels frågor för det aktuella ämnet, men också frågor som kan handla om vad som helst. Även om du inte kan ta beslut om det så kan du ha diskussion.Och det är inte för att vara schysst, utan du måste svara på det enligt lagen.Du kan inte bara vifta bort det, utan du måste svara. Sen kan du lägga det i slutet av dagordningen.&nbsp;</p>



<p>– Det handlar bara om när under stämman. En av obligatoriska punkterna för stämman är ‘övriga frågor&#8217;. Några gör misstaget att lägga den punkten utanför stämmer, men där ska det inte ligga utan det ska vara en punkt innan stämman är slut, förslagsvis som sista punkt.</p>



<p>Är kallelsen felaktig går det ändå att genomföra stämman och godkänna stämmobeslut, förutsatt att <strong>samtliga</strong> medlemmar röstar för att genomföra stämman trots den felaktiga kallelsen. Det räcker alltså inte bara med närvarande medlemmar, utan det måste vara full närvaro, och alla måste rösta för. Det gäller också enskilda ärenden som inte är med på kallelsen, men som av någon anledning seglat upp på stämman.&nbsp;</p>



<h4 class="wp-block-heading">Checklista kallelse</h4>



<ul class="wp-block-list">
<li>Alla ärenden som stämman ska avhandla</li>



<li>Leverera kallelsen till medlemmen enligt stadgarnas bestämmelser </li>



<li>Se till att alla nödvändiga dokument finns tillgängliga för medlemmar i god tid före stämman, förslagsvis i samband med kallelse.&nbsp;</li>



<li>Om stämman ska besluta om uttaxering så <strong>måste</strong> medlemmar få ta del av debiteringslängden även innan stämman.&nbsp;</li>



<li>Det skadar inte att bifoga en dagordning till kallelsen.</li>
</ul>



<h4 class="wp-block-heading">Verksamhetsberättelsen</h4>



<p>På stämman ska styrelsen också presentera verksamhetsberättelsen, eller förvaltningsberättelsen. Berättelsen innehåller alla åtgärder och alla väsentliga händelser för föreningen under året som gått. Det kan vara allt från renoveringar, investeringar, avtalsförändringar eller andra händelser. Verksamhetsberättelsen kan därför gå ut tillsammans med kallelse, så alla medlemmar får ta del av den i god tid.&nbsp;</p>



<p>– Det gäller att ha koll siffrorna, och varför det ser ut som det gör, både bakåt och framåt i tiden. Ska du lägga fram något underlag på stämman som handlar om ekonomi, får det inte vara för komplicerat. Det är viktigt att alla förstår vad det handlar om. Momsfrågan är ett bra exempel som är aktuellt idag. Det är en svår fråga som man måste presentera på en nivå så alla förstår hur det fungerar och hur det påverkar föreningen.&nbsp;</p>



<p>Om föreningen har en valberedelse ska deras förslag till styrelseledamöter och suppleanter presenteras på stämman. Dessa förslag kan, om det är möjligt, också framgå i kallelsen.<strong> </strong>I kallelsen bör det också framgå vilka motioner som medlemmar har skickat in. Styrelsens yttrande eller argumentation till motionen, om det finns, ska också framgå i kallelsen.&nbsp;</p>



<h4 class="wp-block-heading">Genomförande av stämman</h4>



<p>Först måste någon öppna dagordningen och utse föreningsstämmans ordförande. Det kan vara ordförande själv, eller någon annan. Sedan är det dags att tillsätta styrelseledamöter, något man kan göra på en ordinarie stämma oavsett om mandatperioder har gått ut eller inte.&nbsp;</p>



<p>– Ett tips är att utse en stämmoordförande på stämman som inte är ordinarie ordförande i styrelsen. Det kan vara någon annan ur styrelsen eller en extern part. Anledningen till det är att ordinarie ordförande troligtvis måste vara väldigt involverad i alla frågor och diskussioner som stämman berör, och det kan snabbt bli mycket på en och samma gång. </p>



<p>När det är dags för motioner och ärenden som medlemmar har skickat in sedan tidigare, och som framgår av kallelsen, är det upp till föreningen själva att hantera det på bästa sätt.I lagen om förvaltning av samfälligheter skriver man inte något om motioner, även om de flesta föreningar har ändå något typ av system för det.</p>



<p>Styrelsen föreslår sedan för föreningsstämman att antingen rösta för motionen, eller att avslå motionen. Det går också att föreslå för stämman att rösta enligt motionen, men med presenterad justering.&nbsp;</p>



<p>Stämman ska utse en person som för protokoll över vad som sägs och behandlas på stämman. Utöver det ska en justeringsperson som intygar att det som står i protokollet stämmer med verkligheten. Det är stämman som utser både protokollförare och justeringspersoner.&nbsp;</p>



<p>– I protokollet måste det stå att stämman har blivit behörigt kallad, och att stämman har godkänt det. Sen måste det framgå att intäkts -och utgiftsstat har godkänts, och att debiteringslängden har framlagts för stämman.&nbsp;&nbsp;</p>



<h4 class="wp-block-heading">Checklista för stämmoprotokoll:&nbsp;</h4>



<ul class="wp-block-list">
<li>Vilka som varit närvarande</li>



<li>Röstlängd (om föreningen har en gjort en)</li>



<li>Ärenden &amp; beslut&nbsp;</li>



<li>Utfall vid omröstningar</li>



<li>Bekräfta att stämma blivit tillkallad korrekt</li>



<li>Intäkts -och utgiftsstat har godkänts&nbsp;</li>



<li>Att debiteringslängden blivit godkänd</li>



<li>Tillgängligt för alla intressenter <strong>senast</strong> två veckor efter stämma</li>
</ul>



<h4 class="wp-block-heading">Vilka får medverka på stämman?&nbsp;</h4>



<p>Det är föreningens medlemmar som får medverka och rösta. Rättighetshavare,&nbsp; externa styrelsemedlemmar och revisorer får också medverka, de har dock ingen rösträtt. Det kan även förekomma ombud för medlemmar som av någon anledning inte kan medverka.&nbsp;</p>



<p>– Det skadar inte att ha någon som håller koll på turordning för att ställa frågor och fördela ordet. Är man fler än 30 personer så blir det snabbt rörigt.&nbsp;&nbsp;</p>



<h4 class="wp-block-heading">Rättighetshavare får yttra sig&nbsp;</h4>



<p>Alla som är rättighetshavare får yttra sig på stämman. En rättighetshavare kan vara någon som har arrenderätt i en delägarfastighet, servitut, eller hyresrätt i en delägarfastighet. De får däremot inte rösta på stämman. Styrelsen har inte heller någon skyldighet att kalla en rättighetshavare till stämman.&nbsp;</p>



<h4 class="wp-block-heading">Uppskjuten stämma&nbsp;</h4>



<p>Om föreningsstämman blir uppskjuten (ajourneras) ska en ny kallelse, enligt samma förfarande som en vanlig kallelse, gå ut till föreningens medlemmar.&nbsp;&nbsp;</p>



<h4 class="wp-block-heading">Bifoga nödvändiga dokument till kallelsen</h4>



<p>Antingen kan man bifoga dokumenten direkt i kallelsen, eller hänvisa till var medlemmar kan vända sig för att få tag på dessa. Det handlar om dokument som debiteringslängd, årsredovisning (årssammanställning) och revisionsberättelse. Men även andra dokument som är relevanta för föreningsstämman.</p>



<h4 class="wp-block-heading">Röstning</h4>



<p>En fastighet som har flera delägare, vilket är vanligt, har delägarna en röst tillsammans. Skulle de vara oense i en fråga så får de inte rösta i frågan. De måste alltså vara överens för att deras röst ska räknas. Vad som händer om någon av delägarna inte medverkar på stämman kan regleras i stadgarna, därför kan det vara bra att läsa stadgarna innan. </p>



<h4 class="wp-block-heading"><a href="https://samfalligheterna.se/rostrakningsmetoder-valj-ratt-alternativ/"><em>Läs också: </em>Rösträkningsmetoder: Så väljer ni rätt alternativ</a></h4>



<p>Det händer att en delägare röstar för båda, trots att en av delägarna saknas. Det kan dock hända att den frånvarande delägaren klandrar beslutet i efterhand, vilket resulterar i att föreningen får riva upp beslutet.</p>



<p><br>Skulle en omröstning sluta på lika antal röster är det stämmoordförande som har utslagsrösten. Personval avgörs dock genom lottning.</p>



<h3 class="wp-block-heading">Extrastämma &amp; klander&nbsp;</h3>



<p>Skulle en femtedel av medlemmarna (eller fler) begära en extrastämma, till exempel för att behandla fler ärenden, har styrelsen en vecka på sig att kalla till den extrainsatta föreningsstämman ska dessutom hållas så snabbt det går och som stadgarna tillåter. Skulle oinbjudna gäster befinna sig på stämman kan en medlem helt enkelt ‘slänga ut’ denne, om medlemmar inte vill att den ska medverka.&nbsp;</p>



<p>Oim en medlem, eller rättighetshavare, anser att ett beslut på föreningsstämman är felaktigt kan de klandra beslutet. Det kan även handla om invändningar mot uttaxeringen. Då väcker medlemmen talan mot föreningen i mark- och miljödomstolen. Talan måste väckas inom fyra veckor från beslutsdagen. En sådan situation kan exempelvis uppstå om ett beslut bryter mot lagen, kallelsen varit felaktig, eller om stämman använt fel röstmetod i ett ärende på stämman.&nbsp;</p>



<h3 class="wp-block-heading">Digital årsstämma för samfällghetsföreningen</h3>



<p>Sedan den 1 januari 2024 så kan samfälligheter anordna årsstämman digitalt. Samma förfaranden som vid en fysisk stämma gäller, det vill säga att kallelser och information ska ut i tid, och system för rösträkning och deltagande måste finnas.</p>



<p>För att genomföra årsstämman helt digitalt, det vill säga utan någon fysisk plats, kan föreningen först behöva genomföra en stadgeändring. Om det däremot finns möjlighet för medlemmar att även delta fysiskt så behöver föreningen inte göra något.</p>



<p>Kallelsen måste också innehålla vägledning kring hur medlemmar deltar och hur de röstar på den digitala stämman.&nbsp;</p>



<h4 class="wp-block-heading">Läs också:</h4>



<figure class="wp-block-embed is-type-wp-embed is-provider-samf-lligheterna wp-block-embed-samf-lligheterna"><div class="wp-block-embed__wrapper">
<blockquote class="wp-embedded-content" data-secret="vEbd0lwlDe"><a href="https://samfalligheterna.se/vanliga-misstag-infor-stamma-samfallighetsforening/">Vanliga misstag inför samfällighetsföreningens stämma</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; clip: rect(1px, 1px, 1px, 1px);" title="”Vanliga misstag inför samfällighetsföreningens stämma” &ndash; Samfälligheterna" src="https://samfalligheterna.se/vanliga-misstag-infor-stamma-samfallighetsforening/embed/#?secret=XzElaYzPSR#?secret=vEbd0lwlDe" data-secret="vEbd0lwlDe" width="600" height="338" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>

